Creating New Applications | Developer Guide

Overview
Creating an Application Using the CLI
Creating an Application Using the Web Console

Overview

You can create a new OpenShift Enterprise application from source code, images, or templates by using either the OpenShift CLI or web console.

Creating an Application Using the CLI

Creating an Application From Source Code

The new-app command allows you to create applications using source code in a local or remote Git repository.

To create an application using a Git repository in a local directory:

$ oc new-app /path/to/source/code

If using a local Git repository, the repository must have an origin remote that points to a URL accessible by the OpenShift Enterprise cluster.

You can use a subdirectory of your source code repository by specifying a --context-dir flag. To create an application using a remote Git repository and a context subdirectory:

$ oc new-app https://github.com/sclorg/s2i-ruby-container.git \
    --context-dir=2.0/test/puma-test-app

Also, when specifying a remote URL, you can specify a Git branch to use by appending #<branch_name> to the end of the URL:

$ oc new-app https://github.com/openshift/ruby-hello-world.git#beta4

Using new-app results in a build configuration, which creates a new application image from your source code. It also constructs a deployment configuration to deploy the new image, and a service to provide load-balanced access to the deployment running your image.

OpenShift Enterprise automatically detects whether the Docker or Source build strategy is being used, and in the case of Source builds, detects an appropriate language builder image.

Build Strategy Detection

If a Dockerfile is in the repository when creating a new application, OpenShift Enterprise generates a Docker build strategy. Otherwise, it generates a Source strategy.

You can specify a strategy by setting the --strategy flag to either source or docker.

$ oc new-app /home/user/code/myapp --strategy=docker

Language Detection

If creating a Source build, new-app attempts to determine the language builder to use by the presence of certain files in the root of the repository:

Table 1. Languages Detected by `new-app`
Language	Files
`ruby`	*Rakefile, Gemfile, config.ru*
`jee`	*pom.xml*
`nodejs`	*app.json, package.json*
`php`	*index.php, composer.json*
`python`	*requirements.txt, setup.py*
`perl`	*index.pl, cpanfile*

After a language is detected, new-app searches the OpenShift Enterprise server for image stream tags that have a supports annotation matching the detected language, or an image stream that matches the name of the detected language. If a match is not found, new-app searches the Docker Hub registry for an image that matches the detected language based on name.

You can override the image the builder uses for a particular source repository by specifying the image (either an image stream or Docker specification) and the repository, with a ~ as a separator.

For example, to use the myproject/my-ruby image stream with the source in a remote repository:

$ oc new-app myproject/my-ruby~https://github.com/openshift/ruby-hello-world.git

To use the openshift/ruby-20-centos7:latest Docker image stream with the source in a local repository:

$ oc new-app openshift/ruby-20-centos7:latest~/home/user/code/my-ruby-app

Creating an Application From an Image

You can deploy an application from an existing image. Images can come from image streams in the OpenShift Enterprise server, images in a specific registry or Docker Hub registry, or images in the local Docker server.

The new-app command attempts to determine the type of image specified in the arguments passed to it. However, you can explicitly tell new-app whether the image is a Docker image (using the --docker-image argument) or an image stream (using the -i|--image argument).

If you specify an image from your local Docker repository, you must ensure that the same image is available to the OpenShift Enterprise cluster nodes.

For example, to create an application from the DockerHub MySQL image:

$ oc new-app mysql

To create an application using an image in a private registry, specify the full Docker image specification:

$ oc new-app myregistry:5000/example/myimage

If the registry containing the image is not secured with SSL, cluster administrators must ensure that the Docker daemon on the OpenShift Enterprise node hosts is run with the --insecure-registry flag pointing to that registry. You must also tell new-app that the image comes from an insecure registry with the --insecure-registry=true flag.

You can create an application from an existing image stream and tag (optional) for the image stream:

$ oc new-app my-stream:v1

Creating an Application From a Template

You can create an application from a previously stored template or from a template file, by specifying the name of the template as an argument. For example, you can store a sample application template and use it to create an application.

To create an application from a stored template:

$ oc create -f examples/sample-app/application-template-stibuild.json
$ oc new-app ruby-helloworld-sample

To directly use a template in your local file system, without first storing it in OpenShift Enterprise, use the -f|--file argument:

$ oc new-app -f examples/sample-app/application-template-stibuild.json

Template Parameters

When creating an application based on a template, use the -p|--param argument to set parameter values defined by the template:

$ oc new-app ruby-helloworld-sample \
    -p ADMIN_USERNAME=admin,ADMIN_PASSWORD=mypassword

Further Modifying Application Creation

The new-app command generates OpenShift Enterprise objects that will build, deploy, and run the application being created. Normally, these objects are created in the current project using names derived from the input source repositories or the input images. However, new-app allows you to modify this behavior.

The set of objects created by new-app depends on the artifacts passed as input: source repositories, images, or templates.

Table 2. `new-app` Output Objects
Object	Description
`BuildConfig`	A `BuildConfig` is created for each source repository specified in the command line. The `BuildConfig` specifies the strategy to use, the source location, and the build output location.
`ImageStreams`	For `BuildConfig`, two `ImageStreams` are usually created: one to represent the input image (the builder image in the case of `Source` builds or FROM image in case of `Docker` builds), and another one to represent the output image. If a Docker image was specified as input to `new-app`, then an image stream is created for that image as well.
`DeploymentConfig`	A `DeploymentConfig` is created either to deploy the output of a build, or a specified image. The `new-app` command creates EmptyDir volumes for all Docker volumes that are specified in containers included in the resulting `DeploymentConfig`.
`Service`	The `new-app` command attempts to detect exposed ports in input images. It uses the lowest numeric exposed port to generate a service that exposes that port. In order to expose a different port, after `new-app` has completed, simply use the `oc expose` command to generate additional services.
Other	Other objects can be generated when instantiating templates.

Specifying Environment Variables

When generating applications from a source or an image, you can use the -e|--env argument to pass environment variables to the application container at run time:

$ oc new-app openshift/postgresql-92-centos7 \
    -e POSTGRESQL_USER=user \
    -e POSTGRESQL_DATABASE=db \
    -e POSTGRESQL_PASSWORD=password

Specifying Labels

When generating applications from source, images, or templates, you can use the -l|--label argument to add labels to the created objects. Labels make it easy to collectively select, configure, and delete objects associated with the application.

$ oc new-app https://github.com/openshift/ruby-hello-world -l name=hello-world

Viewing the Output Without Creation

To see a dry-run of what new-app will create, you can use the -o|--output argument with a yaml or json value. You can then use the output to preview the objects that will be created, or redirect it to a file that you can edit. Once you are satisfied, you can use oc create to create the OpenShift Enterprise objects.

To output new-app artifacts to a file, edit them, then create them:

$ oc new-app https://github.com/openshift/ruby-hello-world \
    -o yaml > myapp.yaml
$ vi myapp.yaml
$ oc create -f myapp.yaml

Creating Objects With Different Names

Objects created by new-app are normally named after the source repository, or the image used to generate them. You can set the name of the objects produced by adding a --name flag to the command:

$ oc new-app https://github.com/openshift/ruby-hello-world --name=myapp

Creating Objects in a Different Project

Normally, new-app creates objects in the current project. However, you can create objects in a different project that you have access to using the -n|--namespace argument:

$ oc new-app https://github.com/openshift/ruby-hello-world -n myproject

Creating Multiple Objects

The new-app command allows creating multiple applications specifying multiple parameters to new-app. Labels specified in the command line apply to all objects created by the single command. Environment variables apply to all components created from source or images.

To create an application from a source repository and a Docker Hub image:

$ oc new-app https://github.com/openshift/ruby-hello-world mysql

If a source code repository and a builder image are specified as separate arguments, new-app uses the builder image as the builder for the source code repository. If this is not the intent, simply specify a specific builder image for the source using the ~ separator.

Grouping Images and Source in a Single Pod

The new-app command allows deploying multiple images together in a single pod. In order to specify which images to group together, use the + separator. The --group command line argument can also be used to specify the images that should be grouped together. To group the image built from a source repository with other images, specify its builder image in the group:

$ oc new-app nginx+mysql

To deploy an image built from source and an external image together:

$ oc new-app \
    ruby~https://github.com/openshift/ruby-hello-world \
    mysql \
    --group=ruby+mysql

Useful Edits

Following are some specific examples of useful edits to make in the myapp.yaml file.

These examples presume myapp.yaml was created as a result of the oc new-app … -o yaml command.

Example 1. Deploy to Selected Nodes

apiVersion: v1
items:
- apiVersion: v1
  kind: Project  (1)
  metadata:
    name: myapp
    annotations:
      openshift.io/node-selector: region=west  (2)
- apiVersion: v1
  kind: ImageStream
  ...
kind: List
metadata: {}

1	In *myapp.yaml, the section that defines the myapp* project has both `kind: Project` and `metadata.name: myapp`. If this section is missing, you should add it at the second level, as a new item of the list `items`, peer to the `kind: ImageStream` definitions.
2	Add this node selector annotation to the myapp project to cause its pods to be deployed only on nodes that have the label `region=west`.

Creating an Application Using the Web Console

While in the desired project, click Add to Project:

Select either a builder image from the list of images in your project, or from the global library:

Only image stream tags that have the builder tag listed in their annotations appear in this list, as demonstrated here:

kind: "ImageStream"
apiVersion: "v1"
metadata:
  name: "ruby"
  creationTimestamp: null
spec:
  dockerImageRepository: "registry.access.redhat.com/openshift3/ruby-20-rhel7"
  tags:
    -
      name: "2.0"
      annotations:
        description: "Build and run Ruby 2.0 applications"
        iconClass: "icon-ruby"
        tags: "builder,ruby" (1)
        supports: "ruby:2.0,ruby"
        version: "2.0"

1	Including builder here ensures this `ImageStreamTag` appears in the web console as a builder.

Modify the settings in the new application screen to configure the objects to support your application:

1	The builder image name and description.
2	The application name used for the generated OpenShift Enterprise objects.
3	The Git repository URL, reference, and context directory for your source code.
4	Routing configuration section for making this application publicly accessible.
5	Deployment configuration section for customizing deployment triggers and image environment variables.
6	Build configuration section for customizing build triggers.
7	Replica scaling section for configuring the number of running instances of the application.
8	The labels to assign to all items generated for the application. You can add and edit labels for all objects here.

To see all of the configuration options, click the "Show advanced build and deployment options" link.