Overview

You can create a new OpenShift Container Platform application from components including
source or binary code, images and/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 from 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 should have a remote named
origin that points to a URL accessible by the OpenShift Container Platform cluster. If
there is no recognised remote, new-app will create a
binary build.

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

The new-app command creates a build configuration, which itself creates a new application
image
from your source code. The new-app command typically also creates a
deployment
configuration to deploy the new image, and a
service to
provide load-balanced access to the deployment running your image.

If a Jenkinsfile exists in the root or specified context directory of the
source repository when creating a new application, OpenShift Container Platform generates a
Pipeline
build strategy.
Otherwise, if a Dockerfile is found, OpenShift Container Platform
generates a
Docker
build strategy.
Otherwise, it generates a
Source
build strategy.

You can override the build strategy by setting the --strategy flag to either
docker,
pipeline or source.

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

The oc command requires that files containing build sources are available in a
remote Git repository. For all source builds, you must use git remote -v.

Language Detection

If using the Source build strategy, new-app attempts to determine the
language builder to use by the presence of certain files in the root or
specified context directory of the repository:

Table 1. Languages Detected by new-app

Language

Files

dotnet

project.json, *.csproj

jee

pom.xml

nodejs

app.json, package.json

perl

cpanfile, index.pl

php

composer.json, index.php

python

requirements.txt, setup.py

ruby

Gemfile, Rakefile, config.ru

scala

build.sbt

golang

Godeps, main.go

After a language is detected, new-app searches the OpenShift Container Platform 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 container specification) and
the repository, with a ~ as a separator. Note that if this is done,
build strategy detection and
language detection are not carried out.

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

Creating an Application From an Image

You can deploy an application from an existing image. Images can come from image
streams in the OpenShift Container Platform 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 Container Platform 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 Container Platform
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 flag.

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.

Further Modifying Application Creation

The new-app command generates OpenShift Container Platform 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
represents the input image. With Source builds, this is the builder image.
With Docker builds, this is the FROM image.
The second one represents the output image. If a container 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 may be generated when instantiating
templates, according to the template.

Specifying Environment Variables

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

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.

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 Container Platform
objects.

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, specify the required 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: