1. Save the Bash completion code to a file.

   $ oc completion bash > oc_bash_completion

2. Copy the file to /etc/bash_completion.d/.

   $ sudo cp oc_bash_completion /etc/bash_completion.d/

   You can also save the file to a local directory and source it from your .bashrc file instead.

1. Create a file called oc-foo.

   When naming your plug-in file, keep the following in mind:

   • The file must begin with oc- or kubectl- in order to be recognized as a plug-in.
   • The file name determines the command that invokes the plug-in. For example, a plug-in with the file name oc-foo-bar can be invoked by a command of oc foo bar. You can also use underscores if you want the command to contain dashes. For example, a plug-in with the file name oc-foo_bar can be invoked by a command of oc foo-bar.

2. Add the following contents to the file.

   #!/bin/bash
   
   # optional argument handling
   if [[ "$1" == "version" ]]
   then
       echo "1.0.0"
       exit 0
   fi
   
   # optional argument handling
   if [[ "$1" == "config" ]]
   then
       echo $KUBECONFIG
       exit 0
   fi
   
   echo "I am a plugin named kubectl-foo"

Procedure

1. If necessary, update the plug-in file to be executable.

   $ chmod +x <plugin_file>

2. Place the file anywhere in your PATH, such as /usr/local/bin/.

   $ sudo mv <plugin_file> /usr/local/bin/.

3. Run oc plugin list to make sure that the plug-in is listed.

   $ oc plugin list
   The following compatible plugins are available:
   
   /usr/local/bin/<plugin_file>

   If your plug-in is not listed here, verify that the file begins with oc- or kubectl-, is executable, and is on your PATH.

4. Invoke the new command or option introduced by the plug-in.

   For example, if you built and installed the kubectl-ns plug-in from the Sample plug-in repository, you can use the following command to view the current namespace.

   $ oc ns

   Note that the command to invoke the plug-in depends on the plug-in file name. For example, a plug-in with the file name of oc-foo-bar is invoked by the oc foo bar command.

1. Creating resources

   If not already created, odo push creates the following OpenShift Container Platform resources:

   • Deployment config (DC):

     • Two init containers are executed: copy-supervisord and copy-files-to-volume. The init containers copy files onto the emptyDir and the PersistentVolume type of volumes respectively.
     • The application container starts. The first process in the application container is the go-init process with PID=1.

     • go-init process starts the SupervisorD daemon.

       Note

       The user application code has not been copied into the application container yet, so the SupervisorD daemon does not execute the run script.

   • Service
   • Secrets
   • PersistentVolumeClaim

2. Indexing files

   • A file indexer indexes the files in the source code directory. The indexer traverses through the source code directories recursively and finds files which have been created, deleted, or renamed.
   • A file indexer maintains the indexed information in an odo index file inside the .odo directory.
   • If the odo index file is not present, it means that the file indexer is being executed for the first time, and creates a new odo index JSON file. The odo index JSON file contains a file map - the relative file paths of the traversed files and the absolute paths of the changed and deleted files.

3. Pushing code

   Local code is copied into the application container, usually under /tmp/src.

4. Executing assemble-and-restart

   On a successful copy of the source code, the assemble-and-restart script is executed inside the running application container.

Procedure

1. Log in to an OpenShift Container Platform cluster:

   $ odo login -u developer -p developer

2. Create a project:

   $ odo project create myproject
    ✓  Project 'myproject' is ready for use
    ✓  New project created and now using project : myproject

Procedure

1. Create a directory for your components:

   $ mkdir my_components $$ cd my_components

2. Download the example Node.js application:

   $ git clone https://github.com/openshift/nodejs-ex

3. Change the current directory to the directory with your application:

   $ cd <directory name>

4. Add a component of the type Node.js to your application:

   $ odo create nodejs

   Note

   By default, the latest image is used. You can also explicitly specify an image version by using odo create openshift/nodejs:8.

5. Push the initial source code to the component:

   $ odo push

   Your component is now deployed to OpenShift Container Platform.

6. Create a URL and add an entry in the local configuration file as follows:

   $ odo url create --port 8080

7. Push the changes. This creates a URL on the cluster.

   $ odo push

8. List the URLs to check the desired URL for the component.

   $ odo url list

9. View your deployed application using the generated URL.

   $ curl <URL>

1. Edit one of the layout files within the Node.js directory with your preferred text editor.

2. Update your component:

   $ odo push

3. Refresh your application in the browser to see the changes.

Procedure

1. Import the image into OpenShift Container Platform:

   $ oc import-image openjdk18 \
   --from=registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift \
   --confirm

2. Tag the image to make it accessible to odo:

   $ oc annotate istag/openjdk18:latest tags=builder

3. Deploy the image with odo:

   $ odo create openjdk18 --git \
   https://github.com/openshift-evangelists/Wild-West-Backend

Procedure

1. List the applications in the current project:

   $ odo app list
       The project '<project_name>' has the following applications:
       NAME
       app

2. List the components associated with the applications. These components will be deleted with the application:

   $ odo component list
       APP     NAME                      TYPE       SOURCE        STATE
       app     nodejs-nodejs-ex-elyf     nodejs     file://./     Pushed

3. Delete the application:

   $ odo app delete <application_name>
       ? Are you sure you want to delete the application: <application_name> from project: <project_name>

4. Confirm the deletion with Y. You can suppress the confirmation prompt using the -f flag.

Procedure

1. Log in to an OpenShift Container Platform cluster:

   $ odo login -u developer -p developer

2. Create a project:

   $ odo project create myproject
    ✓  Project 'myproject' is ready for use
    ✓  New project created and now using project : myproject

Procedure

1. Import openjdk18 into the cluster:

   $ oc import-image openjdk18 \
   --from=registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift --confirm

2. Tag the image as builder to make it accessible for odo:

   $ oc annotate istag/openjdk18:latest tags=builder

3. Run odo catalog list components to see the created image:

   $ odo catalog list components
   Odo Supported OpenShift Components:
   NAME          PROJECT       TAGS
   nodejs        openshift     10,8,8-RHOAR,latest
   openjdk18     myproject     latest

4. Create a directory for your components:

   $ mkdir my_components $$ cd my_components

5. Download the example back-end application:

   $ git clone https://github.com/openshift-evangelists/Wild-West-Backend backend

6. Change directory to the back-end source directory and check that you have the correct files in the directory:

   $ cd backend
   $ ls
   debug.sh  pom.xml  src

7. Build the back-end source files with Maven to create a JAR file:

   $ mvn package
   ...
   [INFO] --------------------------------------
   [INFO] BUILD SUCCESS
   [INFO] --------------------------------------
   [INFO] Total time: 2.635 s
   [INFO] Finished at: 2019-09-30T16:11:11-04:00
   [INFO] Final Memory: 30M/91M
   [INFO] --------------------------------------

8. Create a component configuration of Java component-type named backend:

   $ odo create openjdk18 backend --binary target/wildwest-1.0.jar
    ✓  Validating component [1ms]
    Please use `odo push` command to create the component with source deployed

   Now the configuration file config.yaml is in the local directory of the back-end component that contains information about the component for deployment.

9. Check the configuration settings of the back-end component in the config.yaml file using:

   $ odo config view
   COMPONENT SETTINGS
   ------------------------------------------------
   PARAMETER         CURRENT_VALUE
   Type              openjdk18
   Application       app
   Project           myproject
   SourceType        binary
   Ref
   SourceLocation    target/wildwest-1.0.jar
   Ports             8080/TCP,8443/TCP,8778/TCP
   Name              backend
   MinMemory
   MaxMemory
   DebugPort
   Ignore
   MinCPU
   MaxCPU

10. Push the component to the OpenShift Container Platform cluster.

    $ odo push
    Validation
     ✓  Checking component [6ms]
    
    Configuration changes
     ✓  Initializing component
     ✓  Creating component [124ms]
    
    Pushing to component backend of type binary
     ✓  Checking files for pushing [1ms]
     ✓  Waiting for component to start [48s]
     ✓  Syncing files to the component [811ms]
     ✓  Building component [3s]

    Using odo push, OpenShift Container Platform creates a container to host the back-end component, deploys the container into a Pod running on the OpenShift Container Platform cluster, and starts the backend component.

11. Validate:

    • The status of the action in odo:

      odo log -f
      2019-09-30 20:14:19.738  INFO 444 --- [           main] c.o.wildwest.WildWestApplication         : Starting WildWestApplication v1.0 onbackend-app-1-9tnhc with PID 444 (/deployments/wildwest-1.0.jar started by jboss in /deployments)

    • The status of the back-end component:

      $ odo list
      APP     NAME        TYPE          SOURCE                             STATE
      app     backend     openjdk18     file://target/wildwest-1.0.jar     Pushed

Procedure

1. Download the example front-end application:

   $ git clone https://github.com/openshift/nodejs-ex

2. Change the current directory to the front-end directory:

   $ cd <directory-name>

3. List the contents of the directory to see that the front end is a Node.js application.

   $ ls
   assets  bin  index.html  kwww-frontend.iml  package.json  package-lock.json  playfield.png  README.md  server.js

   Note

   The front-end component is written in an interpreted language (Node.js); it does not need to be built.

4. Create a component configuration of Node.js component-type named frontend:

   $ odo create nodejs frontend
    ✓  Validating component [5ms]
   Please use `odo push` command to create the component with source deployed

5. Push the component to a running container.

   $ odo push
   Validation
    ✓  Checking component [8ms]
   
   Configuration changes
    ✓  Initializing component
    ✓  Creating component [83ms]
   
   Pushing to component frontend of type local
    ✓  Checking files for pushing [2ms]
    ✓  Waiting for component to start [45s]
    ✓  Syncing files to the component [3s]
    ✓  Building component [18s]
    ✓  Changes successfully pushed to component

Procedure

1. List all the components that are running on the cluster:

   $ odo list
   APP     NAME         TYPE          SOURCE                             STATE
   app     backend      openjdk18     file://target/wildwest-1.0.jar     Pushed
   app     frontend     nodejs        file://./                          Pushed

2. Link the current front-end component to the backend:

   $ odo link backend --port 8080
    ✓  Component backend has been successfully linked from the component frontend
   
   Following environment variables were added to frontend component:
   - COMPONENT_BACKEND_HOST
   - COMPONENT_BACKEND_PORT

   The configuration information of the back-end component is added to the front-end component and the front-end component restarts.

Procedure

1. Create an external URL for the application:

   $ cd frontend
   $ odo url create frontend --port 8080
    ✓  URL frontend created for component: frontend
   
   To create URL on the OpenShift  cluster, use `odo push`

2. Apply the changes:

   $ odo push
   Validation
    ✓  Checking component [21ms]
   
   Configuration changes
    ✓  Retrieving component data [35ms]
    ✓  Applying configuration [29ms]
   
   Applying URL changes
    ✓  URL frontend: http://frontend-app-myproject.192.168.42.79.nip.io created
   
   Pushing to component frontend of type local
    ✓  Checking file changes for pushing [1ms]
    ✓  No file changes detected, skipping build. Use the '-f' flag to force the build.

3. Open the URL in a browser to view the application.

Procedure

1. Change the local directory to the front-end directory:

   $ cd ~/frontend

2. Monitor the changes on the file system using:

   $ odo watch

3. Edit the index.html file to change the displayed name for the game.

   Note

   A slight delay is possible before odo recognizes the change.

   odo pushes the changes to the front-end component and prints its status to the terminal:

   File /root/frontend/index.html changed
   File  changed
   Pushing files...
    ✓  Waiting for component to start
    ✓  Copying files to component
    ✓  Building component

4. Refresh the application page in the web browser. The new name is now displayed.

Procedure

1. List the applications in the current project:

   $ odo app list
       The project '<project_name>' has the following applications:
       NAME
       app

2. List the components associated with the applications. These components will be deleted with the application:

   $ odo component list
       APP     NAME                      TYPE       SOURCE        STATE
       app     nodejs-nodejs-ex-elyf     nodejs     file://./     Pushed

3. Delete the application:

   $ odo app delete <application_name>
       ? Are you sure you want to delete the application: <application_name> from project: <project_name>

4. Confirm the deletion with Y. You can suppress the confirmation prompt using the -f flag.

Procedure

1. Log in to an OpenShift Container Platform cluster:

   $ odo login -u developer -p developer

2. Create a project:

   $ odo project create myproject
    ✓  Project 'myproject' is ready for use
    ✓  New project created and now using project : myproject

Procedure

1. Download the example front-end application:

   $ git clone https://github.com/openshift/nodejs-ex

2. Change the current directory to the front-end directory:

   $ cd <directory-name>

3. List the contents of the directory to see that the front end is a Node.js application.

   $ ls
   assets  bin  index.html  kwww-frontend.iml  package.json  package-lock.json  playfield.png  README.md  server.js

   Note

   The front-end component is written in an interpreted language (Node.js); it does not need to be built.

4. Create a component configuration of Node.js component-type named frontend:

   $ odo create nodejs frontend
    ✓  Validating component [5ms]
   Please use `odo push` command to create the component with source deployed

5. Create a URL to access the frontend interface.

   $ odo url create myurl
    ✓  URL myurl created for component: nodejs-nodejs-ex-pmdp

6. Push the component to the OpenShift Container Platform cluster.

   $ odo push
   Validation
    ✓  Checking component [7ms]
   
    Configuration changes
    ✓  Initializing component
    ✓  Creating component [134ms]
   
    Applying URL changes
    ✓  URL myurl: http://myurl-app-myproject.192.168.42.79.nip.io created
   
    Pushing to component nodejs-nodejs-ex-mhbb of type local
    ✓  Checking files for pushing [657850ns]
    ✓  Waiting for component to start [6s]
    ✓  Syncing files to the component [408ms]
    ✓  Building component [7s]
    ✓  Changes successfully pushed to component

1. List the available services:

   $ odo catalog list services
   NAME                         PLANS
   django-psql-persistent       default
   jenkins-ephemeral            default
   jenkins-pipeline-example     default
   mariadb-persistent           default
   mongodb-persistent           default
   mysql-persistent             default
   nodejs-mongo-persistent      default
   postgresql-persistent        default
   rails-pgsql-persistent       default

2. Choose the mongodb-persistent type of service and see the required parameters:

   $ odo catalog describe service mongodb-persistent
     ***********************        | *****************************************************
     Name                           | default
     -----------------              | -----------------
     Display Name                   |
     -----------------              | -----------------
     Short Description              | Default plan
     -----------------              | -----------------
     Required Params without a      |
     default value                  |
     -----------------              | -----------------
     Required Params with a default | DATABASE_SERVICE_NAME
     value                          | (default: 'mongodb'),
                                    | MEMORY_LIMIT (default:
                                    | '512Mi'), MONGODB_VERSION
                                    | (default: '3.2'),
                                    | MONGODB_DATABASE (default:
                                    | 'sampledb'), VOLUME_CAPACITY
                                    | (default: '1Gi')
     -----------------              | -----------------
     Optional Params                | MONGODB_ADMIN_PASSWORD,
                                    | NAMESPACE, MONGODB_PASSWORD,
                                    | MONGODB_USER

3. Pass the required parameters as flags and wait for the deployment of the database:

   $ odo service create mongodb-persistent --plan default --wait -p DATABASE_SERVICE_NAME=mongodb -p MEMORY_LIMIT=512Mi -p MONGODB_DATABASE=sampledb -p VOLUME_CAPACITY=1Gi

1. Link the database to the front-end service:

   $ odo link mongodb-persistent
    ✓  Service mongodb-persistent has been successfully linked from the component nodejs-nodejs-ex-mhbb
   
   Following environment variables were added to nodejs-nodejs-ex-mhbb component:
   - database_name
   - password
   - uri
   - username
   - admin_password

2. See the environment variables of the application and the database in the Pod:

   $ oc get pods
   NAME                                READY     STATUS    RESTARTS   AGE
   mongodb-1-gsznc                     1/1       Running   0          28m
   nodejs-nodejs-ex-mhbb-app-4-vkn9l   1/1       Running   0          1m
   
   $ oc rsh nodejs-nodejs-ex-mhbb-app-4-vkn9l
   sh-4.3$ env
   uri=mongodb://172.30.126.3:27017
   password=dHIOpYneSkX3rTLn
   database_name=sampledb
   username=user43U
   admin_password=NCn41tqmx7RIqmfv
   sh-4.3$

3. Open the URL in the browser and notice the database configuration in the bottom right:

   $ odo url list

   Request information
   Page view count: 24
   
   DB Connection Info:
   Type:	MongoDB
   URL:	mongodb://172.30.126.3:27017/sampledb

Procedure

1. List the applications in the current project:

   $ odo app list
       The project '<project_name>' has the following applications:
       NAME
       app

2. List the components associated with the applications. These components will be deleted with the application:

   $ odo component list
       APP     NAME                      TYPE       SOURCE        STATE
       app     nodejs-nodejs-ex-elyf     nodejs     file://./     Pushed

3. Delete the application:

   $ odo app delete <application_name>
       ? Are you sure you want to delete the application: <application_name> from project: <project_name>

4. Confirm the deletion with Y. You can suppress the confirmation prompt using the -f flag.

Procedure

1. After an application is deployed, start the port forwarding for your component to debug the application:

   $ odo debug port-forward

2. Attach the debugger bundled in your IDE to the component. Instructions vary depending on your IDE.

Procedure

1. Create a new project:

   $ oc new-project mysql

2. Add a repository of Helm charts to your local Helm client:

   $ helm repo add stable https://kubernetes-charts.storage.googleapis.com/
   "stable" has been added to your repositories

3. Update the repository:

   $ helm repo update

4. Install an example MySQL chart:

   $ helm install example-mysql stable/mysql

5. Verify that the chart has installed successfully:

   $ helm list
   NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
   example-mysql mysql 1 2019-12-05 15:06:51.379134163 -0500 EST deployed mysql-1.5.0 5.7.27

Procedure

1. Create a new project:

   $ oc new-project nodejs-ex-k

2. Download an example Node.js chart that contains OpenShift Container Platform objects:

   $ git clone https://github.com/redhat-developer/redhat-helm-charts

3. Go to the directory with the sample chart:

   $ cd redhat-helm-charts/alpha/nodejs-ex-k/

4. Edit the Chart.yaml file and add a description of your chart:

   apiVersion: v2 1
   name: nodejs-ex-k 2
   description: A Helm chart for OpenShift 3
   icon: https://static.redhat.com/libs/redhat/brand-assets/latest/corp/logo.svg 4

   1

   The chart API version. It should be v2 for Helm charts that require at least Helm 3.

   2

   The name of your chart.

   3

   The description of your chart.

   4

   The URL to an image to be used as an icon.

5. Verify that the chart is formatted properly:

   $ helm lint
   [INFO] Chart.yaml: icon is recommended
   
   1 chart(s) linted, 0 chart(s) failed

6. Install the chart:

   $ cd ..
   $ helm install nodejs-chart nodejs-ex-k

7. Verify that the chart has installed successfully:

   $ helm list
   NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
   nodejs-chart nodejs-ex-k 1 2019-12-05 15:06:51.379134163 -0500 EST deployed nodejs-0.1.0  1.16.0