Verrazzano Enterprise Container Platform – Examples

Docs: Hello World Helidon

Mon, 01 Jan 0001 00:00:00 +0000

The Hello World Helidon example is a Helidon-based service that returns a “Hello World” response when invoked. The example application is specified using Open Application Model (OAM) component and application configuration YAML files, and then deployed by applying those files.

The example application has two endpoints, which differ in configuration source:

/greet- uses a microprofile properties file. Deploy this application by using the instructions here.
/config- uses a Kubernetes ConfigMap. Deploy this application by using the instructions here.

For more information and the code of this application, see the Verrazzano examples.

Docs: Sock Shop

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Install Verrazzano by following the installation instructions.

NOTE: The Sock Shop example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/sockshop, where <VERRAZZANO_HOME> is the root of the Verrazzano project.

Deploy the Sock Shop application

This example application provides various implementations of the Sock Shop Microservices Demo Application. It uses OAM resources to define the application deployment.

Coherence and Helidon in the helidon subdirectory.
Coherence and Micronaut in the micronaut subdirectory.
Coherence and Spring in the spring subdirectory.

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

Create a namespace for the Sock Shop application and add a label identifying the namespace as managed by Verrazzano.
```
$ kubectl create namespace sockshop
$ kubectl label namespace sockshop verrazzano-managed=true
```

To deploy the application, apply the Sock Shop OAM resources. Choose to deploy either the helidon, micronaut, or spring variant.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/helidon/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/helidon/sock-shop-app.yaml -n sockshop

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/micronaut/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/micronaut/sock-shop-app.yaml -n sockshop

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/spring/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/spring/sock-shop-app.yaml -n sockshop

Wait for the Sock Shop application to be ready.

$ kubectl wait \
   --for=condition=Ready pods \
   --all -n sockshop \
   --timeout=300s

Explore the application

The Sock Shop microservices application implements REST API endpoints including:

/catalogue - Returns the Sock Shop catalog. This endpoint accepts the GET HTTP request method.
/register - POST { "username":"xxx", "password":"***", "email":"foo@example.com", "firstName":"foo", "lastName":"bar" } to create a user. This endpoint accepts the POST HTTP request method.

NOTE: The following instructions assume that you are using a Kubernetes environment, such as OKE. Other environments or deployments may require alternative mechanisms for retrieving addresses, ports, and such.

Follow these steps to test the endpoints:

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io \
     -n sockshop \
     -o jsonpath={.items[0].spec.servers[0].hosts[0]})
$ echo $HOST

# Sample output
sockshop-appconf.sockshop.11.22.33.44.nip.io

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
     -n istio-system istio-ingressgateway \
     -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
11.22.33.44

Access the Sock Shop application:

Using the command line

# Get catalogue
$ curl -sk \
   -X GET \
   https://${HOST}/catalogue \
   --resolve ${HOST}:443:${ADDRESS}

# Sample output
[{"count":115,"description":"For all those leg lovers out there....", ...}]

# Add a new user (replace values of username and password)
$ curl -i \
   --header "Content-Type: application/json" \
   --request POST \
   --data '{"username":"foo","password":"****","email":"foo@example.com","firstName":"foo","lastName":"foo"}' \
   -k https://${HOST}/register \
   --resolve ${HOST}:443:${ADDRESS}

# Add an item to the user's cart
$ curl -i \
   --header "Content-Type: application/json" \
   --request POST \
   --data '{"itemId": "a0a4f044-b040-410d-8ead-4de0446aec7e","unitPrice": "7.99"}' \
   -k https://${HOST}/carts/{username}/items \
   --resolve ${HOST}:443:${ADDRESS}

# Get cart items
$ curl -i \
   -k https://${HOST}/carts/{username}/items \
   --resolve ${HOST}:443:${ADDRESS}

# Sample output
[{"itemId":"a0a4f044-b040-410d-8ead-4de0446aec7e","quantity":1,"unitPrice":7.99}]

If you are using nip.io, then you do not need to include --resolve.

Local testing with a browser

Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host name to the ingress gateway’s EXTERNAL-IP address. For example:
```
11.22.33.44 sockshop.example.com
```
Then, you can access the application in a browser at https://sockshop.example.com/catalogue.

If you are using nip.io, then you can access the application in a browser using the HOST variable (for example, https://${HOST}/catalogue). If you are going through a proxy, you may need to add *.nip.io to the NO_PROXY list.
Using your own DNS name
- Point your own DNS name to the ingress gateway’s EXTERNAL-IP address.
- In this case, you would need to edit the sock-shop-app.yaml file to use the appropriate value under the hosts section (such as yourhost.your.domain), before deploying the Sock Shop application.
- Then, you can use a browser to access the application at https://<yourhost.your.domain>/catalogue.

A variety of endpoints associated with the deployed application, are available to further explore the logs, metrics, and such. You can access them according to the directions here.

Troubleshooting

Verify that the application configuration, component, workload, and ingress trait all exist.

$ kubectl get ApplicationConfiguration -n sockshop
$ kubectl get Component -n sockshop
$ kubectl get VerrazzanoCoherenceWorkload -n sockshop
$ kubectl get IngressTrait -n sockshop

Verify that the Sock Shop service pods are successfully created and transition to the READY state. Note that this may take a few minutes and that you may see some of the services terminate and restart.

 $ kubectl get pods -n sockshop

 # Sample output
 NAME             READY   STATUS        RESTARTS   AGE
 carts-coh-0      1/1     Running       0          41s
 catalog-coh-0    1/1     Running       0          40s
 orders-coh-0     1/1     Running       0          39s
 payment-coh-0    1/1     Running       0          37s
 shipping-coh-0   1/1     Running       0          36s
 users-coh-0      1/1     Running       0          35s

Undeploy the application

To undeploy the application, delete the Sock Shop OAM resources. Choose to undeploy either the helidon, micronaut, or spring variant.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/helidon/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/helidon/sock-shop-app.yaml -n sockshop

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/micronaut/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/micronaut/sock-shop-app.yaml -n sockshop

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/spring/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/sock-shop/spring/sock-shop-app.yaml -n sockshop

Delete the namespace sockshop after the application pods are terminated.
```
$ kubectl delete namespace sockshop
```

Docs: Spring Boot

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Install Verrazzano by following the installation instructions.

NOTE: The Spring Boot example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/springboot-app, where VERRAZZANO_HOME is the root of the Verrazzano project.

Deploy the Spring Boot application

This example provides a simple web application developed using Spring Boot. For more information and the source code of this application, see the Verrazzano Examples.

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true istio-injection=enabled

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

Create a namespace for the Spring Boot application and add a label identifying the namespace as managed by Verrazzano.

$ kubectl create namespace springboot
$ kubectl label namespace springboot verrazzano-managed=true istio-injection=enabled

To deploy the application, apply the Spring Boot OAM resources.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/springboot-app/springboot-comp.yaml -n springboot
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/springboot-app/springboot-app.yaml -n springboot

Wait for the Spring Boot application to be ready.

$ kubectl wait \
   --for=condition=Ready pods \
   --all \
   -n springboot \
   --timeout=300s

Explore the application

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io \
     -n springboot \
     -o jsonpath={.items[0].spec.servers[0].hosts[0]})
$ echo $HOST

# Sample output
springboot-appconf.springboot.11.22.33.44.nip.io

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
     -n istio-system istio-ingressgateway \
     -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
11.22.33.44

Access the application:
- Using the command line
```
# The expected response of this query is the HTML of a web page
$ curl -sk \
    https://${HOST} \
    --resolve ${HOST}:443:${ADDRESS}

$ curl -sk \
    https://${HOST}/facts \
    --resolve ${HOST}:443:${ADDRESS}

# Sample output
In 1524, Verrazzano became the first European to enter the New York Harbor and the Hudson River.
```
  If you are using nip.io, then you do not need to include --resolve.
- Local testing with a browser
  
  Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host name to the ingress gateway’s EXTERNAL-IP address. For example:
```
11.22.33.44 springboot.example.com
```
  Then, you can access the application in a browser at https://springboot.example.com/ and https://springboot.example.com/facts.
  
  If you are using nip.io, then you can access the application in a browser using the HOST variable (for example, https://${HOST}/facts). If you are going through a proxy, you may need to add *.nip.io to the NO_PROXY list.
- Using your own DNS name
  - Point your own DNS name to the ingress gateway’s EXTERNAL-IP address.
  - In this case, you would need to have edited the springboot-app.yaml file to use the appropriate value under the hosts section (such as yourhost.your.domain), before deploying the Spring Boot application.
  - Then, you can use a browser to access the application at https://<yourhost.your.domain>/ and https://<yourhost.your.domain>/facts.
    
    The actuator endpoint is accessible under the path /actuator and the Prometheus endpoint exposing metrics data in a format that can be scraped by a Prometheus server is accessible under the path /actuator/prometheus.
A variety of endpoints associated with the deployed application, are available to further explore the logs, metrics, and such. You can access them according to the directions here.

Undeploy the application

To undeploy the application, delete the Spring Boot OAM resources.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/springboot-app/springboot-app.yaml -n springboot
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/springboot-app/springboot-comp.yaml -n springboot

Delete the namespace springboot after the application pod is terminated.
```
$ kubectl delete namespace springboot
```

Docs: Standard Kubernetes Resources

Mon, 01 Jan 0001 00:00:00 +0000

This example demonstrates using standard Kubernetes resources, in conjunction with OAM resources, to define and deploy an application. Several standard Kubernetes resources are used in this example, both as workloads and traits.

Deployment is used as a workload within a Component.
Service is used as a workload within a Component.
Ingress is used as a trait within an ApplicationConfiguration.

Before you begin

Install Verrazzano by following the installation instructions.

Grant permissions

The oam-kubernetes-runtime is not installed with privileges that allow it to create the Kubernetes Ingress resource used in this example. The following steps create a role that allows Ingress resource creation and binds that role to the oam-kubernetes-runtime service account. For this example to work, your cluster admin will need to run the following steps to create the ClusterRole and ClusterRoleBinding.

$ kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: oam-kubernetes-runtime-ingresses
rules:
  - apiGroups:
    - networking.k8s.io
    - extensions
    resources:
    - ingresses
    verbs:
    - create
    - delete
    - get
    - list
    - patch
    - update
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: oam-kubernetes-runtime-ingresses
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: oam-kubernetes-runtime-ingresses
subjects:
  - kind: ServiceAccount
    name: oam-kubernetes-runtime
    namespace: verrazzano-system
EOF

Deploy the application

This example provides an web application using a common example application image. When accessed, the application returns the configured text.

Create the application namespace and add a label identifying the namespace as managed by Verrazzano.

$ kubectl create namespace oam-kube
$ kubectl label namespace oam-kube verrazzano-managed=true istio-injection=enabled

Create a Component containing a Deployment workload.

$ kubectl apply -f - <<EOF
apiVersion: core.oam.dev/v1alpha2
kind: Component
metadata:
  name: oam-kube-dep-comp
  namespace: oam-kube
spec:
  workload:
    kind: Deployment
    apiVersion: apps/v1
    name: oam-kube-dep
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: oam-kube-app
      template:
        metadata:
          labels:
            app: oam-kube-app
        spec:
          containers:
            - name: oam-kube-cnt
              image: hashicorp/http-echo
              args:
                - "-text=hello"
EOF

Create a Component containing a Service workload.

$ kubectl apply -f - <<EOF
apiVersion: core.oam.dev/v1alpha2
kind: Component
metadata:
  name: oam-kube-svc-comp
  namespace: oam-kube
spec:
  workload:
    kind: Service
    apiVersion: v1
    metadata:
      name: oam-kube-svc
    spec:
      selector:
        app: oam-kube-app
      ports:
      - port: 5678 # Default port for image
EOF

Create an ApplicationConfiguration referencing both Components and configuring an ingress trait.

$ kubectl apply -f - <<EOF
apiVersion: core.oam.dev/v1alpha2
kind: ApplicationConfiguration
metadata:
  name: oam-kube-appconf
  namespace: oam-kube
spec:
  components:
    - componentName: oam-kube-dep-comp
    - componentName: oam-kube-svc-comp
      traits:
        - trait:
            apiVersion: networking.k8s.io/v1beta1
            kind: Ingress
            metadata:
              name: oam-kube-ing
              annotations:
                kubernetes.io/ingress.class: istio
            spec:
              rules:
              - host: oam-kube-app.example.com
                http:
                  paths:
                    - path: /example
                      backend:
                        serviceName: oam-kube-svc
                        servicePort: 5678
EOF

Explore the application

Get the host name for the application.

$ export HOST=$(kubectl get ingress \
    -n oam-kube oam-kube-ing \
    -o jsonpath='{.spec.rules[0].host}')
$ echo "HOST=${HOST}"

Get the load balancer address of the ingress gateway.

$ export LOADBALANCER=$(kubectl get ingress \
    -n oam-kube oam-kube-ing \
    -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo "LOADBALANCER=${LOADBALANCER}"

Access the application.

$ curl http://${HOST}/example --resolve ${HOST}:80:${LOADBALANCER}

# Expected response
hello

Undeploy the application

To undeploy the application, delete the namespace created. This will result in the deletion of all explicitly and implicitly created resources in the namespace.

$ kubectl delete namespace oam-kube

If desired, the cluster admin also can remove the created ClusterRole and ClusterRoleBinding.

$ kubectl delete ClusterRoleBinding oam-kubernetes-runtime-ingresses
$ kubectl delete ClusterRole oam-kubernetes-runtime-ingresses

Docs: ToDo List

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Install Verrazzano by following the installation instructions.
To download the example image, you must first accept the license agreement.
- In a browser, navigate to https://container-registry.oracle.com/ and sign in.
- Search for example-todo and weblogic.
- For each one:
  - Select the image name in the results.
  - From the drop-down menu, select your language and click Continue.
  - Then read and accept the license agreement.

NOTE: The ToDo List example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/todo-list, where <VERRAZZANO_HOME> is the root of the Verrazzano project.

All files and paths in this document are relative to <VERRAZZANO_HOME>/examples/todo-list.

Deploy the ToDo List application

ToDo List is an example application containing a WebLogic component. For more information and the source code of this application, see the Verrazzano Examples.

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true istio-injection=enabled

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

Create a namespace for the ToDo List example and add a label identifying the namespace as managed by Verrazzano.

$ kubectl create namespace todo-list
$ kubectl label namespace todo-list verrazzano-managed=true istio-injection=enabled

Create a docker-registry secret to enable pulling the ToDo List example image from the registry.

$ kubectl create secret docker-registry tododomain-repo-credentials \
        --docker-server=container-registry.oracle.com \
        --docker-username=YOUR_REGISTRY_USERNAME \
        --docker-password=YOUR_REGISTRY_PASSWORD \
        --docker-email=YOUR_REGISTRY_EMAIL \
        -n todo-list

Replace YOUR_REGISTRY_USERNAME, YOUR_REGISTRY_PASSWORD, and YOUR_REGISTRY_EMAIL with the values you use to access the registry.

Create and label secrets for the WebLogic domain:

# Replace the values of the WLS_USERNAME and WLS_PASSWORD environment variables as appropriate.
$ export WLS_USERNAME=<username>
$ export WLS_PASSWORD=<password>
$ kubectl create secret generic tododomain-weblogic-credentials \
    --from-literal=password=$WLS_PASSWORD \
    --from-literal=username=$WLS_USERNAME \
    -n todo-list

$ kubectl create secret generic tododomain-jdbc-tododb \
    --from-literal=username=$WLS_USERNAME \
    --from-literal=password=$WLS_PASSWORD \
    -n todo-list

$ kubectl -n todo-list label secret tododomain-jdbc-tododb weblogic.domainUID=tododomain

Note that the ToDo List example application is preconfigured to use specific secret names. For the source code of this application, see the Verrazzano Examples.

To deploy the application, apply the example resources.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/todo-list/todo-list-components.yaml -n todo-list
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/todo-list/todo-list-application.yaml -n todo-list

Wait for the ToDo List application to be ready. You can monitor its progress by listing pods and inspecting the output, or you can use the kubectl wait command. You may need to repeat the kubectl wait command several times before it is successful. The tododomain-adminserver pod may take a while to be created and Ready.
```
$ kubectl get pods -n todo-list

# -or- #

$ kubectl wait pod \
   --for=condition=Ready tododomain-adminserver \
   -n todo-list
```

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io \
     -n todo-list \
     -o jsonpath='{.items[0].spec.servers[0].hosts[0]}')
$ echo $HOST

# Sample output
todo-appconf.todo-list.10.11.12.13.nip.io

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
     -n istio-system istio-ingressgateway \
     -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
10.11.12.13

Access the ToDo List application:
- Using the command line
```
# The expected response of this query is the HTML of a web page
$ curl -sk \
   https://${HOST}/todo/ \
   --resolve ${HOST}:443:${ADDRESS}
```
  If you are using nip.io, then you do not need to include --resolve.
- Local testing with a browser
  
  Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host name to the ingress gateway’s EXTERNAL-IP address. For example:
```
10.11.12.13 todo.example.com
```
  Then, you can access the application in a browser at https://todo.example.com/todo.
  
  If you are using nip.io, then you can access the application in a browser using the HOST variable (for example, https://${HOST}/todo). If you are going through a proxy, then you may need to add *.nip.io to the NO_PROXY list.
- Using your own DNS name
  - Point your own DNS name to the ingress gateway’s EXTERNAL-IP address.
  - In this case, you would need to have edited the todo-list-application.yaml file to use the appropriate value under the hosts section (such as yourhost.your.domain), before deploying the ToDo List application.
  - Then, you can use a browser to access the application at https://<yourhost.your.domain>/todo/.
    
    Accessing the application in a browser opens the page, “Derek’s ToDo List”, with an edit field and an Add button that lets you add tasks.
A variety of endpoints associated with the deployed ToDo List application, are available to further explore the logs, metrics, and such. You can access them according to the directions here.

Access the WebLogic Server Administration Console

To access the Console from the machine where you are running kubectl:

Set up port forwarding.
```
$ kubectl port-forward pods/tododomain-adminserver 7001:7001 -n todo-list
```
NOTE: If you are using the Oracle Cloud Infrastructure Cloud Shell to run kubectl, in order to access the Console using port forwarding, you will need to run kubectl on another machine.
Access the WebLogic Server Administration Console from your browser.
```
http://localhost:7001/console
```

NOTE

It is recommended that the WebLogic Server Administration Console not be exposed publicly.

Troubleshooting

Verify that the application configuration, domain, and ingress trait all exist.

$ kubectl get ApplicationConfiguration -n todo-list

# Sample output
NAME           AGE
todo-appconf   19h

$ kubectl get Domain -n todo-list

# Sample output
NAME          AGE
todo-domain   19h

$ kubectl get IngressTrait -n todo-list

# Sample output
NAME                           AGE
todo-domain-trait-7cbd798c96   19h

Verify that the WebLogic Administration Server and MySQL pods have been created and are running. Note that this will take several minutes.

$ kubectl get pods -n todo-list

# Sample output
NAME                     READY   STATUS    RESTARTS   AGE
mysql-5c75c8b7f-vlhck    2/2     Running   0          19h
tododomain-adminserver   4/4     Running   0          19h

Undeploy the application

To undeploy the application, delete the ToDo List OAM resources.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/todo-list/todo-list-application.yaml -n todo-list
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/todo-list/todo-list-components.yaml -n todo-list

Delete the namespace todo-list after the application pods are terminated. The secrets created for the WebLogic domain also will be deleted.
```
$ kubectl delete namespace todo-list
```

Docs: Bob's Books

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Install Verrazzano by following the installation instructions.
To download the example image, you must first accept the license agreement.
- In a browser, navigate to https://container-registry.oracle.com/ and sign in.
- Search for example-bobbys-coherence, example-bobbys-front-end, example-bobs-books-order-manager, example-roberts-coherence, and weblogic.
- For each one:
  - Select the image name in the results.
  - From the drop-down menu, select your language and click Continue.
  - Then read and accept the license agreement.
NOTE: The Bob’s Books example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/bobs-books, where <VERRAZZANO_HOME> is the root of the Verrazzano project.

Overview

Bob’s Books consists of three main parts:

A back-end “order processing” application, which is a Java EE application with REST services and a very simple JSP UI, which stores data in a MySQL database. This application runs on WebLogic Server.
A front-end web store “Robert’s Books”, which is a general book seller. This is implemented as a Helidon microservice, which gets book data from Coherence, uses a Coherence cache store to persist data for the order manager, and has a React web UI.
A front-end web store “Bobby’s Books”, which is a specialty children’s book store. This is implemented as a Helidon microservice, which gets book data from a (different) Coherence cache store, interfaces directly with the order manager, and has a JSF web UI running on WebLogic Server.

For more information and the source code of this application, see the Verrazzano Examples.

Deploy the example application

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true istio-injection=enabled

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

Create a namespace for the example and add a label identifying the namespace as managed by Verrazzano.

$ kubectl create namespace bobs-books
$ kubectl label namespace bobs-books verrazzano-managed=true istio-injection=enabled

Create a docker-registry secret to enable pulling the example image from the registry.

$ kubectl create secret docker-registry bobs-books-repo-credentials \
        --docker-server=container-registry.oracle.com \
        --docker-username=YOUR_REGISTRY_USERNAME \
        --docker-password=YOUR_REGISTRY_PASSWORD \
        --docker-email=YOUR_REGISTRY_EMAIL \
        -n bobs-books

Replace YOUR_REGISTRY_USERNAME, YOUR_REGISTRY_PASSWORD, and YOUR_REGISTRY_EMAIL with the values you use to access the registry.

Create secrets for the WebLogic domains:

# Replace the values of the WLS_USERNAME and WLS_PASSWORD environment variables as appropriate.
$ export WLS_USERNAME=<username>
$ export WLS_PASSWORD=<password>
$ kubectl create secret generic bobbys-front-end-weblogic-credentials \
    --from-literal=password=$WLS_PASSWORD \
    --from-literal=username=$WLS_USERNAME \
    -n bobs-books

$ kubectl create secret generic bobs-bookstore-weblogic-credentials \
    --from-literal=password=$WLS_PASSWORD \
    --from-literal=username=$WLS_USERNAME \
    -n bobs-books

$ kubectl create secret generic mysql-credentials \
    --from-literal=username=$WLS_USERNAME \
    --from-literal=password=$WLS_PASSWORD \
    --from-literal=url=jdbc:mysql://mysql.bobs-books.svc.cluster.local:3306/books \
    -n bobs-books

Note that the example application is preconfigured to use specific secret names. For the source code of this application, see the Verrazzano Examples. If you want to use secret names that are different from what is specified in the source code, you will need to update the corresponding YAML file and rebuild the Docker images for the example application.

To deploy the application, apply the example resources.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/bobs-books/bobs-books-comp.yaml -n bobs-books
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/bobs-books/bobs-books-app.yaml -n bobs-books

Wait for all of the pods in the Bob’s Books example application to be ready. You can monitor their progress by listing the pods and inspecting the output, or you can use the kubectl wait command.

You may need to repeat the kubectl wait command several times before it is successful. The WebLogic Server and Coherence pods may take a while to be created and Ready.
```
$ kubectl get pods -n bobs-books

# -or- #

$ kubectl wait \
    --for=condition=Ready pods \
    --all -n bobs-books \
    --timeout=600s
```

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
    -n istio-system istio-ingressgateway \
    -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
11.22.33.44

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io bobs-books-bobs-books-gw \
    -n bobs-books \
    -o jsonpath='{.spec.servers[0].hosts[0]}')
$ echo $HOST

# Sample output
bobs-books.bobs-books.11.22.33.44.nip.io

Access the application. To access the application in a browser, you will need to do one of the following:
- Option 1: If you are using nip.io, then you can access the application using the generated host name. For example:
  - Robert’s Books UI at https://bobs-books.bobs-books.11.22.33.44.nip.io/.
  - Bobby’s Books UI at https://bobs-books.bobs-books.11.22.33.44.nip.io/bobbys-front-end/.
  - Bob’s order manager UI at https://bobs-books.bobs-books.11.22.33.44.nip.io/bobs-bookstore-order-manager/orders.
- Option 2: Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host used by the application to the external IP address assigned to your gateway. For example:
```
11.22.33.44 bobs-books.example.com
```
  Then, you can use a browser to access the application, as shown:
  - Robert’s Books UI at https://bobs-books.example.com/.
  - Bobby’s Books UI at https://bobs-books.example.com/bobbys-front-end/.
  - Bob’s order manager UI at https://bobs-books.example.com/bobs-bookstore-order-manager/orders.
- Option 3: Alternatively, point your own DNS name to the load balancer’s external IP address. In this case, you would need to have edited the bobs-books-app.yaml file to use the appropriate values under the hosts section for the application (such as your-roberts-books-host.your.domain), before deploying the application. Then, you can use a browser to access the application, as shown:
  - Robert’s Books UI at https://<your-roberts-books-host.your.domain>/.
  - Bobby’s Books UI at https://<your-bobbys-books-host.your.domain>/bobbys-front-end/.
  - Bob’s order manager UI at https://<your-bobs-orders-host.your.domain>/.

Access the applications using the WLS Administration Console

Use the WebLogic Server Administration Console to access the applications as follows.

NOTE

It is recommended that the WebLogic Server Administration Console not be exposed publicly.

Access bobs-bookstore

Set up port forwarding.
```
$ kubectl port-forward pods/bobs-bookstore-adminserver 7001:7001 -n bobs-books
```
NOTE: If you are using the Oracle Cloud Infrastructure Cloud Shell to run kubectl, in order to access the WebLogic Server Administration Console using port forwarding, you will need to run kubectl on another machine.
Access the WebLogic Server Administration Console from your browser.
```
http://localhost:7001/console
```

Access bobbys-front-end

Set up port forwarding.
```
$ kubectl port-forward pods/bobbys-front-end-adminserver 7001:7001 -n bobs-books
```
NOTE: If you are using the Oracle Cloud Infrastructure Cloud Shell to run kubectl, in order to access the WebLogic Server Administration Console using port forwarding, you will need to run kubectl on another machine.
Access the WebLogic Server Administration Console from your browser.
```
http://localhost:7001/console
```

Troubleshooting

Verify that the application configuration, domains, Coherence resources, and ingress trait all exist.

$ kubectl get ApplicationConfiguration -n bobs-books
$ kubectl get Domain -n bobs-books
$ kubectl get Coherence -n bobs-books
$ kubectl get IngressTrait -n bobs-books

Verify that the service pods are successfully created and transition to the READY state. Note that this may take a few minutes and that you may see some of the services terminate and restart.

$ kubectl get pods -n bobs-books

# Sample output
NAME                                                READY   STATUS    RESTARTS   AGE
bobbys-helidon-stock-application-868b5965c8-dk2xb   3/3     Running   0          19h
bobbys-coherence-0                                  2/2     Running   0          19h
bobbys-front-end-adminserver                        3/3     Running   0          19h
bobbys-front-end-managed-server1                    3/3     Running   0          19h
bobs-bookstore-adminserver                          3/3     Running   0          19h
bobs-bookstore-managed-server1                      3/3     Running   0          19h
mysql-669665fb54-9m8wq                              2/2     Running   0          19h
robert-helidon-96997fcd5-kzjkf                      3/3     Running   0          19h
robert-helidon-96997fcd5-nlswm                      3/3     Running   0          19h
roberts-coherence-0                                 2/2     Running   0          17h
roberts-coherence-1                                 2/2     Running   0          17h

Undeploy the application

To undeploy the application, delete the Bob’s Books OAM resources.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/bobs-books/bobs-books-app.yaml -n bobs-books
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/bobs-books/bobs-books-comp.yaml -n bobs-books

Delete the namespace bobs-books after the application pods are terminated. The secrets created for the WebLogic domain also will be deleted.
```
$ kubectl delete namespace bobs-books
```

Docs: Multicluster

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

Prior to running the multicluster examples, complete the multicluster installation and managed cluster registration documented here.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Hello Config World Helidon

This example is a Helidon-based service that returns a “HelloConfig World” response when invoked. The application configuration uses a Kubernetes ConfigMap, instead of the default, microprofile properties file.

Before you begin

Install Verrazzano by following the installation instructions.

NOTE: The Hello World Helidon configuration example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/helidon-config, where <VERRAZZANO_HOME> is the root of the Verrazzano project.

Deploy the Hello Config World Helidon application

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true istio-injection=enabled

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

Create a namespace for the application and add a label identifying the namespace as managed by Verrazzano.

$ kubectl create namespace helidon-config
$ kubectl label namespace helidon-config verrazzano-managed=true istio-injection=enabled

To deploy the application, apply the helidon-config OAM resources.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/helidon-config/helidon-config-comp.yaml -n helidon-config
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/helidon-config/helidon-config-app.yaml -n helidon-config

Wait for the application to be ready.

$ kubectl wait \
   --for=condition=Ready pods \
   --all -n helidon-config \
   --timeout=300s

Explore the application

The Hello World Helidon configuration example implements a REST API endpoint, /config, which returns a message {"message":"HelloConfig World!"} when invoked.

NOTE: The following instructions assume that you are using a Kubernetes environment such as OKE. Other environments or deployments may require alternative mechanisms for retrieving addresses, ports, and such.

Follow these steps to test the endpoints:

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io helidon-config-helidon-config-appconf-gw \
     -n helidon-config \
     -o jsonpath={.spec.servers[0].hosts[0]})
$ echo $HOST

# Sample output
helidon-config-appconf.helidon-config.11.22.33.44.nip.io

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
     -n istio-system istio-ingressgateway \
     -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
11.22.33.44

Access the application:
- Using the command line
```
$ curl -sk \
   -X GET \
   https://${HOST}/config \
   --resolve ${HOST}:443:${ADDRESS}

# Expected response output
{"message":"HelloConfig World!"}
```
  If you are using nip.io, then you do not need to include --resolve.
- Local testing with a browser
  
  Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host name to the ingress gateway’s EXTERNAL-IP address. For example:
```
11.22.33.44 helidon-config.example.com
```
  Then you can access the application in a browser at https://<host>/config.
  
  If you are using nip.io, then you can access the application in a browser using the HOST variable (for example, https://${HOST}/config). If you are going through a proxy, then you may need to add *.nip.io to the NO_PROXY list.
- Using your own DNS name
  - Point your own DNS name to the ingress gateway’s EXTERNAL-IP address.
  - In this case, you would need to edit the helidon-config-app.yaml file to use the appropriate value under the hosts section (such as yourhost.your.domain), before deploying the helidon-config application.
  - Then, you can use a browser to access the application at https://<yourhost.your.domain>/config.
A variety of endpoints associated with the deployed application, are available to further explore the logs, metrics, and such. You can access them according to the directions here.

Troubleshooting

Verify that the application configuration, domain, and ingress trait all exist.

$ kubectl get ApplicationConfiguration -n helidon-config
$ kubectl get IngressTrait -n helidon-config

Verify that the helidon-config service pods are successfully created and transition to the READY state. Note that this may take a few minutes and that you may see some of the services terminate and restart.

 $ kubectl get pods -n helidon-config

 # Sample output
 NAME                                         READY   STATUS    RESTARTS   AGE
 helidon-config-deployment-676d97c7d4-wkrj2   3/3     Running   0          5m39s

Undeploy the application

To undeploy the application, delete the Hello Config World Helidon OAM resources.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/helidon-config/helidon-config-app.yaml -n helidon-config
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/helidon-config/helidon-config-comp.yaml -n helidon-config

Delete the namespace helidon-config after the application pod is terminated.
```
$ kubectl delete namespace helidon-config
```

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Hello World Helidon

This example is a Helidon-based service that returns a “Hello World” response when invoked. The application configuration uses the default, microprofile properties file.

Before you begin

Install Verrazzano by following the installation instructions.

NOTE: The Hello World Helidon example application deployment files are contained in the Verrazzano project located at <VERRAZZANO_HOME>/examples/hello-helidon, where <VERRAZZANO_HOME> is the root of the Verrazzano project.

Deploy the Hello World Helidon application

NOTE

To run this application in the default namespace:

$kubectl label namespace default verrazzano-managed=true istio-injection=enabled

If you chose the default namespace, you can skip Step 1. and ignore the -n option in the rest of the commands.

To run the application in a namespace other than default namespace, create a namespace for the application and add a label identifying the namespace as managed by Verrazzano.
```
$ kubectl create namespace hello-helidon
$ kubectl label namespace hello-helidon verrazzano-managed=true istio-injection=enabled
```

To deploy the application, apply the hello-helidon OAM resources.

$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/hello-helidon/hello-helidon-comp.yaml -n hello-helidon
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/hello-helidon/hello-helidon-app.yaml -n hello-helidon

Wait for the application to be ready.

$ kubectl wait \
   --for=condition=Ready pods \
   --all \
   -n hello-helidon \
   --timeout=300s

Explore the application

The Hello World Helidon microservices application implements a REST API endpoint, /greet, which returns a message {"message":"Hello World!"} when invoked.

Follow these steps to test the endpoints:

Get the generated host name for the application.

$ HOST=$(kubectl get gateways.networking.istio.io hello-helidon-hello-helidon-appconf-gw \
     -n hello-helidon \
     -o jsonpath='{.spec.servers[0].hosts[0]}')
$ echo $HOST

# Sample output
hello-helidon-appconf.hello-helidon.11.22.33.44.nip.io

Get the EXTERNAL_IP address of the istio-ingressgateway service.

$ ADDRESS=$(kubectl get service \
     -n istio-system istio-ingressgateway \
     -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ echo $ADDRESS

# Sample output
11.22.33.44

Access the application:
- Using the command line
```
$ curl -sk \
   -X GET \
   https://${HOST}/greet \
   --resolve ${HOST}:443:${ADDRESS}

# Expected response output
{"message":"Hello World!"}
```
  If you are using nip.io, then you do not need to include --resolve.
- Local testing with a browser
  
  Temporarily, modify the /etc/hosts file (on Mac or Linux) or c:\Windows\System32\Drivers\etc\hosts file (on Windows 10), to add an entry mapping the host name to the ingress gateway’s EXTERNAL-IP address. For example:
```
11.22.33.44 hello-helidon.example.com
```
  Then you can access the application in a browser at https://<host>/greet.
  
  If you are using nip.io, then you can access the application in a browser using the HOST variable (for example, https://${HOST}/greet). If you are going through a proxy, then you may need to add *.nip.io to the NO_PROXY list.
- Using your own DNS name
  - Point your own DNS name to the ingress gateway’s EXTERNAL-IP address.
  - In this case, you would need to edit the hello-helidon-app.yaml file to use the appropriate value under the hosts section (such as yourhost.your.domain), before deploying the hello-helidon application.
  - Then, you can use a browser to access the application at https://<yourhost.your.domain>/greet.
A variety of endpoints associated with the deployed application, are available to further explore the logs, metrics, and such. You can access them according to the directions here.

Troubleshooting

Verify that the application configuration, domain, and ingress trait all exist.

$ kubectl get ApplicationConfiguration -n hello-helidon
$ kubectl get IngressTrait -n hello-helidon

Verify that the hello-helidon service pods are successfully created and transition to the READY state. Note that this may take a few minutes and that you may see some of the services terminate and restart.

 $ kubectl get pods -n hello-helidon

 # Sample output
 NAME                                      READY   STATUS    RESTARTS   AGE
 hello-helidon-workload-676d97c7d4-wkrj2   2/2     Running   0          5m39s

Undeploy the application

To undeploy the application, delete the Hello World Helidon OAM resources.

$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/hello-helidon/hello-helidon-app.yaml -n hello-helidon
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/v1.2.2/examples/hello-helidon/hello-helidon-comp.yaml -n hello-helidon

Delete the namespace hello-helidon after the application pod is terminated.
```
$ kubectl delete namespace hello-helidon
```