Red Hat OpenShift Developer II: Building and Deploying Cloud-native Applications

The oc new-app command creates an application and makes it available within the cluster.

In its simplest form, oc new-app takes a single URL argument that points to either a Git repository or a container image. If the URL points to a Git repository, then OpenShift must containerize the application before it can deploy it. Consequently, oc determines the container image build strategy by following this process:

The oc new-app command provides the following options to customize the application build:

To get a complete list of options, and to see a list of examples, run the oc new-app -h command.

The oc new-app command adds the following resources to the current project to support building and deploying an application:

The following command deploys a MySQL service by using the mysql image stream and adds the db=mysql label to the resources that it creates. The -e options provide the environment variables that the container needs for configuring the database credentials.

[user@host ~]$ oc new-app -i mysql \
-e MYSQL_USER=user -e MYSQL_PASSWORD=pass \
-e MYSQL_DATABASE=testdb -l db=mysql

By default, the resources that oc new-app creates use the name of the application Git repository or the existing container image as a base name. Also, the oc new-app command assigns the app label with this default name to the resources it creates. The oc new-app command has the --name option to provide a different default name.

The following command creates an application from source code in the PHP programming language.

[user@host ~]$ oc new-app -i php \
https://gitserver.example.com/myrepo.git \
--name=hello \
--as-deployment-config

After the build and deployment processes complete, use the oc get all command to display the resources in the current project. The output shows that the oc new-app command creates some additional resources when using the --as-deployment-config option:

[user@host ~]$ oc get all
NAME                 READY   STATUS      RESTARTS   AGE
pod/hello-1-8hm7p    1/1     Running     0          19m 
pod/hello-1-build    0/1     Completed   0          19m 
pod/hello-1-deploy   0/1     Completed   0          19m 

NAME                            DESIRED   CURRENT   READY   AGE
replicationcontroller/hello-1   1         1         1       19m 

NAME            TYPE      CLUSTER-IP      EXTERNAL-IP PORT(S)           AGE
service/hello   ClusterIP 172.30.73.222   <none>      8080/TCP,8443/TCP 19m 

NAME                      REVISION DESIRED CURRENT TRIGGERED BY
deploymentconfig.../hello 1        1       1       config,image(hello:latest) 

NAME                                   TYPE     FROM   LATEST
buildconfig.build.openshift.io/hello   Source   Git    1 

NAME                              TYPE    FROM        STATUS    STARTED  DURATION
build.build.openshift.io/hello-1  Source  Git@ddfc7fe Complete  19 ...   26s 

NAME                                  IMAGE REPOSITORY       TAGS     UPDATED
imagestream.image.openshift.io/hello  .../project-name/hello latest   16 ... 

The following command creates an application from source code in the PHP programming language by using a deployment instead of a deployment configuration:

[user@host ~]$ oc new-app \
--name hello -i php \
--code http://gitserver.example.com/mygitrepo.git

If your application expects resources such as routes, secrets, or persistent volume claims, then create them by running separate oc commands.

You can delete resources that the oc new-app command creates by using a single oc delete command with the --selector option and the app label. The following command deletes the resources created by the previous oc new-app command:

[user@host ~]$ oc delete all --selector app=test

To create an application that has multiple components you can run oc new-app several times. For example, to create a Node.js application with a database you could:

If you want to inspect resource definitions without creating the resources in the current project, use the -o option:

[user@host ~]$ oc new-app \
-o yaml registry.example.com/mycontainerimage

The resource definitions are sent to the standard output and can be redirected to a file. The resulting file can then be customized or inserted into a template definition.

To deploy an application by using the odo deploy command, define the tasks that satisfy your outer loop requirements. Then, you must create commands to implement each individual task and a composite command to run the outer loop commands in sequence. Finally, in the composite command, define the group with the kind property set to deploy and the isDefault property set to true. The following devfile provides a simplified example for outer loop development with odo. This devfile declares a composite command, which runs the following commands:

This devfile also relies on a parent devfile that might provide additional features, or default behavior that this devfile can override.

schemaVersion: 2.2.0
metadata:
  name: nodejs
  version: 2.1.1
  displayName: Node.js Runtime
  description: Stack with Node.js 16
  tags: ["Node.js", "Express", "ubi8"]
  projectType: "Node.js"
  language: "JavaScript"
  provider: Red Hat
  supportUrl: https://github.com/devfile-samples/devfile-support#support-information
parent: 
  id: nodejs
  registryUrl: "https://registry.devfile.io"
components:
  - name: image-build 
    image:
      imageName: nodejs-image:latest 
      dockerfile:
        uri: Dockerfile
        buildContext: .
        rootRequired: false
  - name: kubernetes-deploy 
    kubernetes:
      uri: deploy.yaml
commands: 
  - id: build-image
    apply:
      component: image-build
  - id: deployk8s
    apply:
      component: kubernetes-deploy
  - id: deploy
    composite:
      commands:
        - build-image
        - deployk8s
      group: 
        kind: deploy
        isDefault: true

This devfile has some implicit requirements to work:

With the devfile.yaml file in place and all the requirements met, the odo deploy command executes the outer loop steps.

[user@host ~]$ odo deploy
  __
 /  \__     Running the application in Deploy mode using nodejs Devfile
 \__/  \    Namespace: odo-example
 /  \__/    odo version: v3.11.0
 \__/

↪ Building & Pushing Image: registry.ocp4.example.com/nodejs-nodejs-image:4673 
 •  Building image locally  ...
[1/2] STEP 1/3: FROM registry.access.redhat.com/ubi8/nodejs-16:latest
[1/2] STEP 2/3: COPY package.json package-lock.json* ./
--> Using cache 8ba8...1e0c
--> 8ba8d939abb
...output omitted...
[2/2] COMMIT registry.ocp4.example.com/nodejs-nodejs-image:4673
--> 54961796442
Successfully tagged registry.ocp4.example.com/nodejs-nodejs-image:4459
549617964421f7b134e9f5dff7b2bb3b7e49b6dcb7ef357b50ec3fc2f38d0572
 ✓  Building image locally [2s]
 •  Pushing image to container registry  ...
...output omitted...
Storing signatures
 ✓  Pushing image to container registry [1s] 

↪ Deploying Kubernetes Component: my-nodejs 
 ✓  Creating resource Deployment/my-nodejs

↪ Deploying Kubernetes Component: my-nodejs-svc 

Your Devfile has been successfully deployed

To provide devfile portability, odo can customize the container image names to work with your container registry. This image renaming process works for the image names that exists in the devfile or in the Kubernetes resources that the devfile references.

The image renaming logic only triggers if you define the ImageRegistry preference by running the following command:

[user@host ~]$ odo preference set ImageRegistry REGISTRY_URL/NAMESPACE

To select an image name for renaming, you must create an image component with an imageName property that contains a relative image. A relative image name does not include the container registry.

...
components:
  - image:
      imageName: "my-relative-image"
    name: relative-image
...

The final image names have the following pattern:

ImageRegistry/DevfileName-ImageName:UniqueId

You can verify the results by inspecting the image registry where odo creates the images or by inspecting the Kubernetes sources that odo creates in the cluster.