$ oc new-app /path/to/source/code
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.
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,
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
#<branch_name> to the end of the URL:
$ oc new-app https://github.com/openshift/ruby-hello-world.git#beta4
new-app command creates a build configuration, which itself creates a new application
from your source code. The
new-app command typically also creates a
configuration to deploy the new image, and a
provide load-balanced access to the deployment running your image.
OpenShift Container Platform automatically detects whether the
strategy should be used, and in the case of
detects an appropriate language builder image.
Build Strategy Detection
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
Otherwise, if a Dockerfile is found, OpenShift Container Platform
Otherwise, it generates a
You can override the build strategy by setting the
--strategy flag to either
$ oc new-app /home/user/code/myapp --strategy=docker
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:
Gemfile, Rakefile, config.ru
After a language is detected,
new-app searches the OpenShift Container Platform server for
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
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:
$ oc new-app myproject/my-ruby~https://github.com/openshift/ruby-hello-world.git
To use the openshift/ruby-20-centos7:latest container image stream with the source in a local repository:
$ oc new-app openshift/ruby-20-centos7:latest~/home/user/code/my-ruby-app
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.
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
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
cluster administrators must ensure that the Docker daemon on the OpenShift Container Platform
node hosts is run with the
$ oc new-app my-stream:v1
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 Container Platform, use the
$ oc new-app -f examples/sample-app/application-template-stibuild.json
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 -p ADMIN_PASSWORD=mypassword
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.
Other objects may be generated when instantiating templates, according to the template.
$ oc new-app openshift/postgresql-92-centos7 \ -e POSTGRESQL_USER=user \ -e POSTGRESQL_DATABASE=db \ -e POSTGRESQL_PASSWORD=password
The variables can also be read from file using the
$ cat postgresql.env POSTGRESQL_USER=user POSTGRESQL_DATABASE=db POSTGRESQL_PASSWORD=password $ oc new-app openshift/postgresql-92-centos7 --env-file=postgresql.env
Additionally, environment variables can be given on standard input by using
$ cat postgresql.env | oc new-app openshift/postgresql-92-centos7 --env-file=-
See Managing Environment Variables for more information.
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
To see a dry-run of what
new-app will create, you can use the
argument with a
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
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
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
--name flag to the command:
$ oc new-app https://github.com/openshift/ruby-hello-world --name=myapp
new-app creates objects in the current project. However, you can
create objects in a different project that you have access to using the
$ oc new-app https://github.com/openshift/ruby-hello-world -n myproject
new-app command allows creating multiple applications specifying multiple
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
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 ruby+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
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
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 Container Platform 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||Build configuration section for customizing build triggers.|
|6||Deployment configuration section for customizing deployment triggers and image environment variables.|
|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.