Verrazzano Enterprise Container Platform – Examples

Docs: Argo CD

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

Argo CD is a Kubernetes deployment tool that uses Git repositories as the source of truth. It monitors running applications and compares the deployed state against the desired one in Git. Argo CD lets you visualize the differences and provides methods to automatically or manually update the live state with the desired target state. For more information, see the Argo CD documentation.

In a multicluster Verrazzano environment, Argo CD integration depends on Rancher being enabled on the admin cluster. Argo CD connects to managed clusters using the Rancher proxy, to create the required resources for Argo CD cluster registration.

Before you begin

Install Verrazzano and set up a multicluster environment by following these instructions.
- Because Argo CD is not enabled by default, you must first enable argoCD on the admin cluster.
- When you register managed clusters, they are automatically registered in Argo CD.
Access the Argo CD console using the instructions at Access Verrazzano.
After you set up your application in the Argo CD console, those registered clusters will be available for you to select, deploy, and manage applications.

Configure repositories

In the Argo CD console, configure repositories that will contain the Kubernetes resources for deploying an application.

The following is a sample procedure to configure a private Git repository through HTTPS.

Log in to the Argo CD console.
In the left navigation, click Settings.
Click Repositories.
Click Connect Repo.
Select VIA HTTPS as the connection method.
For Project, specify default.
NOTE: Unless they are grouped together, all the projects are defined in the default level.
For Repository URL, provide the required URL.
If it is a private repository and a user name and password is required to connect to the repository, enter the required credentials.
NOTE: The other fields are optional and based on how the Git repository is configured.
Click Connect and verify that the connection status displayed is Successful.

Deploy applications

To deploy applications in a custom namespace, create Argo CD applications that specify the Git repository path, which Argo CD requires to synchronize and deploy the applications in the specified namespace.

NOTE: You can either pre-create a namespace and label it or auto-create a namespace when deploying an application.

This example provides information about how to deploy the Hello-helidon application. The Hello-helidon application and component YAML files are available at Hello World Helidon.

Log in to the Argo CD console.
Click New App.
Specify a name for the application.
For Project Name, select default.
Select the required Sync Policy option:
- Automatic - By default, every three minutes, Argo CD checks the specified Git repository and synchronizes the updates in Kubernetes to the Git repository.
- Manual - For manually synchronizing the updates to the Git repository, use the Manual option.
If you want to auto-create a namespace, in the Sync Options section, select Auto-Create Namespace.
By auto-creating the namespace, the application will be deployed outside of the service mesh. The best practice is to pre-create the namespace and label it.
Under the Source section, enter the following:
- Repository URL: https://github.com/verrazzano/verrazzano/
- Revision: master
- Path: Path in the repository where the Kubernetes resource definitions are listed. For example: examples/helidon-config
Under the Destination section, do the following:
- Cluster URL: Select the cluster to which you want to deploy the applications.
- Namespace: Specify the namespace in which you want to deploy the applications. The instructions in this sample use hello-helidon as the namespace.
Click Create.
If you selected Manual as the Sync Policy option, then click Sync. In the Synchronize Resources section, select all the resources, and then click Synchronize.
This creates the Argo CD application and a pictorial representation of the deployed applications is displayed.

Verify the deployed application

The Hello World Helidon microservices application implements a REST API endpoint, /config, which returns a message {"message":"Hello 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 hello-helidon-helidon-config-appconf-gw \
     -n hello-helidon \
     -o jsonpath='{.spec.servers[0].hosts[0]}')
$ echo $HOST

# Sample output
helidon-config-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}/config \
   --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>/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 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>/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.

Undeploy applications

Log in to the Argo CD console.
Select the application that you want to undeploy and then click Delete.
Enter the name of the application and then click OK.
This deletes all the resources created by the specific application except for the namespaces.

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 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/master/examples/bobs-books/bobs-books-comp.yaml -n bobs-books
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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 WebLogic Server 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
```

Verify the deployed application

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/master/examples/bobs-books/bobs-books-app.yaml -n bobs-books
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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: 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: 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: 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 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:

For helidon:
```
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/helidon/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/helidon/sock-shop-app.yaml -n sockshop
```
For micronaut:
```
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/micronaut/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/micronaut/sock-shop-app.yaml -n sockshop
```
For spring:
```
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/spring/sock-shop-comp.yaml -n sockshop
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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 example application.
- Using the command line
  
  a. 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....", ...}]
```
  b. 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}
```
  c. 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}

# Sample output
{"itemId":"a0a4f044-b040-410d-8ead-4de0446aec7e","quantity":1,"unitPrice":7.99}
```
  d. 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.

Verify the deployed application

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.

For helidon:
```
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/helidon/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/helidon/sock-shop-app.yaml -n sockshop
```
For micronaut:
```
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/micronaut/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/micronaut/sock-shop-app.yaml -n sockshop
```
For spring:
```
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/examples/sock-shop/spring/sock-shop-comp.yaml -n sockshop
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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 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/master/examples/springboot-app/springboot-comp.yaml -n springboot
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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/master/examples/springboot-app/springboot-app.yaml -n springboot
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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 a 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 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. The password must be at least 8 alphanumeric characters with at least one number or special character.
```
# 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/master/examples/todo-list/todo-list-components.yaml -n todo-list
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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.
```
$ kubectl get pods -n todo-list
```
Alternatively, you can use the kubectl wait commands. However, if it is run before the respective pods are created, then the kubectl wait commands may report error: no matching resources found. Specifically, the tododomain-adminserver pod may take a while to be created and Ready, so you may need to repeat the kubectl wait command several times before it is successful.
```
$ kubectl wait pod \
     --for=condition=Ready \
     -l app.oam.dev/component=todo-mysql-deployment \
     -n todo-list \
     --timeout=5m
$ kubectl wait pod \
     --for=condition=Ready \
     -l weblogic.serverName=AdminServer \
     -n todo-list \
     --timeout=5m
```
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.

Verify the deployed application

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/master/examples/todo-list/todo-list-application.yaml -n todo-list
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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:

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/master/examples/helidon-config/helidon-config-comp.yaml -n helidon-config
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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.

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/master/examples/helidon-config/helidon-config-app.yaml -n helidon-config
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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/master/examples/hello-helidon/hello-helidon-comp.yaml -n hello-helidon
$ kubectl apply -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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-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/master/examples/hello-helidon/hello-helidon-app.yaml -n hello-helidon
$ kubectl delete -f https://raw.githubusercontent.com/verrazzano/verrazzano/master/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
```