2.6. Creating a multicomponent application with odo

Procedure

1. Log in to an OpenShift Container Platform cluster:

   $ odo login -u developer -p developer

2. Create a project:

   $ odo project create myproject

   Example output

    ✓  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

   Example output

   Odo Devfile Components:
   NAME                 DESCRIPTION                            REGISTRY
   java-maven           Upstream Maven and OpenJDK 11          DefaultDevfileRegistry
   java-openliberty     Open Liberty microservice in Java      DefaultDevfileRegistry
   java-quarkus         Upstream Quarkus with Java+GraalVM     DefaultDevfileRegistry
   java-springboot      Spring Boot® using Java                DefaultDevfileRegistry
   nodejs               Stack with NodeJS 12                   DefaultDevfileRegistry
   
   Odo OpenShift Components:
   NAME        PROJECT       TAGS                                                                           SUPPORTED
   java        openshift     11,8,latest                                                                    YES
   dotnet      openshift     2.1,3.1,latest                                                                 NO
   golang      openshift     1.13.4-ubi7,1.13.4-ubi8,latest                                                 NO
   httpd       openshift     2.4-el7,2.4-el8,latest                                                         NO
   nginx       openshift     1.14-el7,1.14-el8,1.16-el7,1.16-el8,latest                                     NO
   nodejs      openshift     10-ubi7,10-ubi8,12-ubi7,12-ubi8,latest                                         NO
   perl        openshift     5.26-el7,5.26-ubi8,5.30-el7,latest                                             NO
   php         openshift     7.2-ubi7,7.2-ubi8,7.3-ubi7,7.3-ubi8,latest                                     NO
   python      openshift     2.7-ubi7,2.7-ubi8,3.6-ubi7,3.6-ubi8,3.8-ubi7,3.8-ubi8,latest                   NO
   ruby        openshift     2.5-ubi7,2.5-ubi8,2.6-ubi7,2.6-ubi8,2.7-ubi7,latest                            NO
   wildfly     openshift     10.0,10.1,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,8.1,9.0,latest     NO

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 to the back-end source directory:

   $ cd backend

7. Check that you have the correct files in the directory:

   $ ls

   Example output

   debug.sh  pom.xml  src

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

   $ mvn package

   Example output

   ...
   [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] --------------------------------------

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

   $ odo create openjdk18 backend --binary target/wildwest-1.0.jar

   Example output

    ✓  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.

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

    $ odo config view

    Example output

    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

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

    $ odo push

    Example output

    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.

12. Validate:

    • The status of the action in odo:

      $ odo log -f

      Example output

      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

      Example output

      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 frontend

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

   $ cd frontend

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

   $ ls

   Example output

   README.md       openshift       server.js       views
   helm            package.json    tests

   注意

   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

   Example output

    ✓  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

   Example output

   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

   Example output

   OpenShift Components:
   APP     NAME         PROJECT     TYPE          SOURCETYPE     STATE
   app     backend      testpro     openjdk18     binary         Pushed
   app     frontend     testpro     nodejs        local          Pushed

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

   $ odo link backend --port 8080

   Example output

    ✓  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. Navigate to the frontend directory:

   $ cd frontend

2. Create an external URL for the application:

   $ odo url create frontend --port 8080

   Example output

    ✓  URL frontend created for component: frontend
   
   To create URL on the OpenShift  cluster, use `odo push`

3. Apply the changes:

   $ odo push

   Example output

   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.

4. 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.

   注意

   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

   Example output

       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

   Example output

       APP     NAME                      TYPE       SOURCE        STATE
       app     nodejs-nodejs-ex-elyf     nodejs     file://./     Pushed

3. Delete the application:

   $ odo app delete <application_name>

   Example output

       ? 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.