Cloud Native CI/CD: The Ultimate Checklist

Choosing a software solution means checking the right boxes, and being “cloud native” has bubbled to the top of most lists. But cloud native is a box built of boxes of its own.

For a CI/CD solution like JFrog Pipelines, cloud native starts by being “born in the cloud” to natively execute in, build for, test in, and deploy to cloud computing environments.

But what boxes does a CI/CD solution really need to tick to complete that larger cloud native box? Let’s make that list and see how Pipelines makes its mark.

What Makes Cloud Native

Being cloud native means effectively utilizing modern cloud technologies by following cloud native best practices. When you do, you can fully exploit the inherent benefits of the cloud, making solutions efficient, resilient, dynamically scalable, and always available.

At minimum, that means designing for the cloud from the start. The best cloud native solutions harness the full dynamism of the cloud, delivering speed and access simultaneously. 

What does this mean for a CI/CD solution? When we created JFrog Pipelines, we asked ourselves, “What would cloud native CI/CD look like?” Here are the top things we decided:

  1. Built on Cloud Native Standards
  2. Infrastructure Agnostic
  3. Infinitely and Dynamically Scalable
  4. Configure as Code
  5. Observable
  6. Enable Cloud Native Development

Let’s take a look at what each of these means, and how we addressed them in Pipelines CI/CD.

1. Built on Cloud Native Standards

When you update your automobile engine, you need to use tools and parts designed to fit. Sure, you might make something else work but how well and for how long?

The same principle applies to your CI/CD. Any solution run in a cloud should use the established technologies – immutable containers, microservices, and orchestration –  meant to make cloud computing work at its best.

Runs on Docker and Kubernetes

Like the rest of the JFrog Platform, Pipelines relies on Docker and Kubernetes to deploy and orchestrate its own microservices. So you can use the cloud native tools you know to control, monitor, and analyze the operation of your entire DevOps system, as well as Pipelines’ RESTful CI/CD APIs to enable automated configuration and oversight.

JFrog DevOps Platform

Cloud Native Builds

Pipelines CI/CD doesn’t just run in the cloud, it performs builds cloud natively. Each step of your pipeline is by default executed in an immutable runtime container on a build machine node. Each step can run in the environment and configuration it needs, without the things it doesn’t need, and will produce the same results every time.

You can use the set of runtime Docker images Pipelines provides out of the box, or you can create your own custom runtime images. Or, if you need to, you can run any step directly on the host VM instead.

cloud native ci/cd runtimes

2. Infrastructure Agnostic

To be cloud native, your CI/CD must be interoperable on many systems, regardless of the underlying hardware. It can require a minimum set of resources such as storage and memory, but should be able to operate with many types.

Any Cloud, Anywhere

Pipelines CI/CD is cloud nimble as well. It is available as a managed service on the major cloud providers (AWS, Azure, and soon on Google Cloud Platform), and can be installed as a self-managed system on any public cloud, on an on-prem cloud in your own datacenter, or a hybrid of on-prem and public clouds. Once running, it operates with the same features and functionality on all platforms.

multicloud ci/cd

This full congruence is critical to enabling a hybrid or multicloud strategy, so you never have to compromise features to interoperate cloud-to-cloud or cloud-to-on-prem. Your developers will never have to think about what platform their CI/CD is running on, because it always looks and functions the same.

3. Infinitely and Dynamically Scalable

Scalability is what the cloud is all about, to serve changing demand, support growing teams, dynamically scale down to save on infrastructure costs, and stretch your operations across the globe. And you need all your services to be able to scale up and down quickly without interrupting work. 

On-Demand Machines

Pipelines CI/CD is as elastic as the cloud it runs in, and smart enough to respond to high and low demand. Through dynamic build nodes, Pipelines can fetch build resources from a cloud service or K8s when they’re needed and release them when they’re not. On-demand computing keeps your CI/CD humming nonstop without limit, while helping contain your cloud service costs.

on-demand ci/cd nodes

One CI/CD, Many Pipelines

This cloud native feature enables pipeline concurrency, with a single, central installation of Pipelines driving many CI/CD pipelines at once. To further support that growing number of users and jobs, Pipelines can be deployed with high availability through as many redundant, load-balanced instances as you need to scale infinitely.

concurrent ci/cd pipelines

4. Configure as Code

Pipelines uses a declarative DSL to define workflows that are based on YAML, “the language of cloud native” that also powers technologies like Kubernetes and Helm.

GitOps for CI/CD

This cloud native practice brings a developer-focused experience to configuring CI/CD, enabling the same software best practices used with the rest of your code.  Pipelines syncs developers’ CI/CD DSL files from where they are stored in Git source control repositories, and can trigger execution on a new commit, pull request, or other action. 

By being stored under version control separate from the Pipelines application, it’s easy to reliably reload your declarative pipelines for any needed systems restore, transfer, or recovery, keeping downtime as brief as possible. Pipelines also empowers you to construct complex, multi-part “pipelines of pipelines” from separate, interdependent DSL files.

What, Not How

Pipelines’ native steps provide out-of-the-box access to most common CI/CD operations for building, promoting, and distributing artifacts. These declarative steps know how to perform their operations, you only have to specify a small set of key:value pair definitions that fit naturally in YAML. You can create your pipelines by assembling these pre-built steps, eliminating the need to write your own command scripts.

cloud native ci/cd code

5. Observable

With a reliance on machine virtualization through containers, interfaces, and orchestration, cloud native systems are inherently opaque. So cloud native CI/CD must provide you ways to ask questions about its state and get actionable answers. 

Interactive Diagrams and Logs

Pipelines’ rich workflow diagrams enable you to see how your steps connect and watch the progress of your pipelines as they execute. Click to reveal what’s taking place on your build nodes in real time, or view the logs to diagnose issues. Pipelines captures a complete record of every run for you to examine.

interactive ci/cd pipelines

Machine Utilization

The Pipelines UI through the JFrog Platform provides visibility into the allocation and activity of build machine nodes and their supporting resources.

ci/cd machine utilization


Like all the components of the JFrog Platform, Pipelines provides a comprehensive set of RESTful APIs for you to query and command your CI/CD server. Using these facilities, you can monitor CI/CD resource utilization through your own custom applications, as well as automate configuration.

6. Enable Cloud Native Development

Cloud native CI/CD can’t just be cloud native, it must help you build cloud native. It should include the facilities you need to develop and produce your applications as containerized microservices that can run efficiently in the cloud.

Pipelines provides out-of-the-box integrations with essential cloud native tools like Docker registries and Kubernetes, enabling you to deliver the apps you build to the cloud.

Container Smart

Pipelines makes it easy to build for the variety of package types enabled by Artifactory, including Docker. Native steps make Pipelines ready out of the box to build Docker images and push to Docker registries in Artifactory or elsewhere. 

Ready at the Helm

Pipelines native steps also enable Helm, both for publishing Helm charts to repositories, and deploying to Kubernetes as part of continuous delivery.

Building a Kubernetes Registry

As part of the JFrog Platform, Pipelines is naturally integrated with Artifactory, making DevOps best practices a seamless part of your CI/CD. Enabling traceability of your builds by publishing build info metadata for every artifact  is essential to knowing what’s being deployed to your Kubernetes clusters.

In the Cloud, For the Cloud

Cloud native means making the best use of the cloud to create robust, elastic solutions that are available anytime, from anywhere. 

But cloud native CI/CD means going even beyond those grand requirements. Pipelines is a cloud native DevOps solution that can build applications in the cloud, but also for the cloud as well.

Take a look at Pipelines by getting started for free in the cloud!