OpenShift offers four practical ways to build an application: start from the Developer Catalog, import a Git repository with a Devfile or Dockerfile, use Source-to-Image (S2I), or automate delivery with OpenShift Pipelines. Choose based on how quickly you want to start, where you want build instructions to live, how much control you need over the image, and whether delivery needs multiple automated steps.
Which OpenShift application-building route should you use?
| Route | Starting speed | Source-control ownership | Customization | Automation depth |
|---|---|---|---|---|
| Developer Catalog and console | Fastest for exploring platform-provided samples, services, and builder images | Depends on the selected resource and workflow | Guided choices and platform-provided components | Basic creation; add delivery automation as needed |
| Git import with Devfile or Dockerfile | Quick when a repository and build instructions are ready | Application definitions and instructions can live in the repository | Devfile or Dockerfile specifies the workflow and image build details | Can be paired with delivery automation |
| Source-to-Image (S2I) | Quick when a suitable builder image fits the application | Source is the input; build configuration can set build behavior | Builder-image conventions, with configurable build settings | Build-focused; use Pipelines for multi-step delivery |
| OpenShift Pipelines (Tekton) | Requires defining or selecting pipeline tasks | Pipeline definitions can be managed alongside application code | Orchestrates build, test, approval, promotion, and deployment steps | Deepest orchestration of the four routes |
The OpenShift 4.8 application guide documents catalog-based creation and the From Git, From Devfile, and From Dockerfile workflows. The exact labels and available catalog items can differ across OpenShift versions and cluster configuration. OpenShift 4.8: Creating applications using the Developer perspective
1. Create an application from the Developer Catalog
Use the catalog when you want a guided starting point rather than beginning with a build definition. The Developer perspective provides a catalog of samples, services, and builder images that can be added to a project.
Typical console flow
- Open the OpenShift web console and switch to the Developer perspective.
- Select the project where you want the application.
- Open the catalog or application-creation flow and choose a sample, service, or builder image.
- Follow the prompts to configure the resource and create it in the project.
This is useful for exploration, trying a supported sample, or using a standardized platform component. It is less suitable when you need every build instruction represented explicitly in source control; in that case, consider importing Git with a Devfile or Dockerfile.
#1 Best Overall
- Get NVMe solid state performance with up to 1050MB/s read and 1000MB/s write speeds in a portable, high-capacity drive(1) (Based on internal testing; performance may be lower depending on host device & other factors. 1MB=1,000,000 bytes.)
- Up to 3-meter drop protection and IP65 water and dust resistance mean this tough drive can take a beating(3) (Previously rated for 2-meter drop protection and IP55 rating. Now qualified for the higher, stated specs.)
- Use the handy carabiner loop to secure it to your belt loop or backpack for extra peace of mind.
- Help keep private content private with the included password protection featuring 256‐bit AES hardware encryption.(3)
- Easily manage files and automatically free up space with the SanDisk Memory Zone app.(5). Non-Operating Temperature -20°C to 85°C
2. Import Git source with a Devfile or Dockerfile
Choose a repository-driven workflow when the application source and its build instructions should be maintained together. In the documented OpenShift 4.8 guide, you can import from Git or select a Devfile or Dockerfile workflow. A Devfile describes a development workspace and related configuration; a Dockerfile gives direct instructions for building an image.
This route makes build intent easier to review and change with application code. A Dockerfile is appropriate when you need more explicit image-level control. A Devfile provides a structured development configuration, while the Git source remains the project’s starting point.
Rank #2
- Solid state performance with up to 800MB/s read speeds in a portable drive. (Based on internal testing; performance may be lower depending on host device, interface, usage conditions and other factors. 1MB=1,000,000 bytes.)
- Back up your content and memories on a storage solution that fits seamlessly into your mobile lifestyle.
- Take it with you on your adventures—up to two-meter drop protection means this durable drive can take a beating. (Based on internal testing.)
- Secure it to your belt loop or backpack for extra peace of mind thanks to the tough rubber hook.
- From Sandisk, a brand professional photographers trust to take on assignments.
When this route fits
- Your team already stores application code in Git.
- You want changes to build or development configuration reviewed through normal repository practices.
- You need control beyond a catalog’s guided defaults, but do not yet need a multi-stage delivery pipeline.
3. Build with Source-to-Image (S2I)
S2I combines application source with a builder image to produce an image that runs the assembled application. Red Hat defines it as “a framework that makes it easy to write images that take application source code as an input and produce a new image that runs the assembled application as output.” Red Hat OpenShift 4.12: Understanding image builds
In practice, select a builder image suited to the application, provide source code, and configure the build. The builder supplies conventions for assembling the application, so S2I can avoid requiring you to write every image-building step yourself. OpenShift’s 4.12 documentation notes that S2I generates a Dockerfile whose first FROM instruction uses the builder image. Source configuration and BuildConfig settings can supply environment values. Red Hat OpenShift 4.12: Understanding image builds
Rank #3
- Easily store and access 2TB to content on the go with the Seagate Portable Drive, a USB external hard drive
- Designed to work with Windows or Mac computers, this external hard drive makes backup a snap just drag and drop
- To get set up, connect the portable hard drive to a computer for automatic recognition no software required
- This USB drive provides plug and play simplicity with the included 18 inch USB 3.0 cable
- The available storage capacity may vary.
S2I is a good fit when a compatible builder image covers your framework and you want a conventional source-to-image build. If you need custom image assembly beyond that convention, a Dockerfile or custom build approach may offer a better fit.
4. Automate delivery with OpenShift Pipelines
OpenShift Pipelines uses Tekton to orchestrate software delivery. Use it when the process is more than building an image—for example, when it needs repeatable build and test tasks, security checks, approvals, image promotion, or deployment. Pipelines are especially useful when the order and outcomes of those steps need to be defined and reused.
Rank #4
- NEARLY 2X FASTER THAN OUR PREVIOUS GENERATION(8) – move 1,000 high-res photos in under 60 seconds(6) with up to 2000MB/s transfer speeds(2).
- IP65 RATING AND UP TO 3M DROP PROTECTION(3) – protects against spills and drops.
- POCKET-SIZED – fits easily in pockets and small bags.
- SPACE TO OWN YOUR AI CONTENT – speed and capacity to download your high-res clips and photo edits.
- 256-BIT AES ENCRYPTION(4) – helps keep private files secure with password protection.
Do not confuse current Tekton-based OpenShift Pipelines with the older Pipeline BuildConfig strategy. OpenShift 4 documentation marks that BuildConfig strategy as deprecated; for CI/CD orchestration, use the OpenShift Pipelines/Tekton terminology and tooling instead. Red Hat OpenShift 4.12: Build strategies
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Use the CLI when you want to create reusable application resources
The oc new-app command can create an application from source code, an image, or a template. For example, to create an application from a Git repository:
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Best Value
- Easily store and access 5TB of content on the go with the Seagate portable drive, a USB external hard Drive
- Designed to work with Windows or Mac computers, this external hard drive makes backup a snap just drag and drop
- To get set up, connect the portable hard drive to a computer for automatic recognition software required
- This USB drive provides plug and play simplicity with the included 18 inch USB 3.0 cable
- The available storage capacity may vary.
oc new-app https://github.com/sclorg/nodejs-exThe command detects or uses the supplied input and can create associated resources. When given source code, OpenShift may create a build configuration, deployment configuration, and service automatically. Review the generated resources and the command output, since the resources depend on the input and what the cluster can identify. Red Hat OpenShift 4.12: Developer CLI commands
Use a template for a repeatable resource set
A template packages reusable resource definitions. Processing a template can generate resources such as services, build configurations, and deployment configurations, and can be done from the CLI or web console. Choose a template when you want to reuse a known set of application resources rather than define each one from scratch. Red Hat OpenShift 4.12: Using templates
How OpenShift builds fit together
OpenShift build documentation describes Source-to-Image, Pipeline, Docker, and Custom build strategies, and lists Git, Dockerfile, Binary, Image, input-secret, and external-artifact sources. These are build mechanics and inputs—not four mutually exclusive ways to create an application. For example, a Git-based application can use S2I, while a delivery pipeline can orchestrate a build and later deployment. Red Hat OpenShift 4.12: Understanding image builds
Quick Recap
- Start with the catalog when guided creation and platform-provided components matter most.
- Use Git with a Devfile or Dockerfile when build or development instructions should be versioned with the application.
- Use S2I when a builder image’s conventions suit the app and you want source assembled into a runnable image.
- Use OpenShift Pipelines when delivery requires coordinated, repeatable steps beyond a single build.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
