Creating New Applications | Developer Guide (2023)

Creating an Application From Source Code

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

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

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

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 byappending #<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 buildconfiguration, which creates a new applicationimagefrom your source code. It also constructs adeploymentconfiguration to deploy the new image, and aservice toprovide load-balanced access to the deployment running your image.

Build Strategy Detection

If a Dockerfile is in the repository when creating a new application,OpenShift Enterprise generates aDockerbuild strategy. Otherwise, it generates aSourcestrategy.

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

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

Language Detection

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

After a language is detected, new-app searches the OpenShift Enterprise server forimagestream 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 isnot found, new-app searches the Docker Hubregistry for an image that matches the detected language based on name.

You can override the image the builder uses for a particular sourcerepository 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 aremote 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 imagestreams in the OpenShift Enterprise server, images in a specific registry orDocker Hub registry, or images in the localDocker server.

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

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 fullDocker image specification:

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

You can create an application from an existingimagestream 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 storedtemplate or from a template file, byspecifying the name of the template as an argument. For example, you can store asampleapplication 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 itin 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, andrun the application being created. Normally, these objects are created in thecurrent project using names derived from the input source repositories or theinput images. However, new-app allows you to modify this behavior.

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

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

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

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

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

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

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

$ oc new-app nginx+mysql

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

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