Frame 481609
Pipeline studio

Written by

Technical Head

Abhilash A

April 28, 2023 . 4 min read

The ultimate pipeline builder for DevOps teams

If you’ve ever tried building a pipeline without a low code editor, you know firsthand the challenges that come with writing code. The process can be time-consuming and frustrating, from troubleshooting errors to managing intricate workflows. 

However, you can streamline your workflow and get around problems such as higher complexity, error handling and debugging, version control, security Issues, handling dependencies, testing, monitoring, and scalability problems, by using a low code pipeline builder. In this blog, we’ll explore the advantages of using a low code editor, such as improved productivity, streamlined teamwork, and quicker development times. Learn how a low code editor like Ozone Pipeline Studio can revolutionize the way you create pipelines!

Ozone Pipeline Studio is a GUI that allows users to drag and drop task templates from a task catalog that contains more than 100 task templates covering all devops phases,(code, build, test, release, deploy, operate, monitor, plan) to create pipelines.  It is constructed over the Tekton DAG but expands on it to provide much, much more.

It’s crucial to comprehend Tekton and its ideas before delving into the Ozone Pipeline Studio’s specifics. 

What is Tekton?

Tekton is an open-source Kubernetes native framework for creating and managing pipelines for continuous integration and delivery. It allows teams to work together and automate their software delivery process by offering a flexible and extensible way to define, run, and manage pipelines.

Tekton Pipelines, Tasks, and Releases 

Tekton uses the YAML syntax for declarative pipelines and consists of tasks. Some basic terms in Tekton are as follows:

  • Pipeline: A set of tasks configured to execute in series, parallel, or both.
  • Task: A sequence of steps as commands, binaries, or scripts.
  • PipelineRun: Execution of a pipeline with one or more tasks. Instantiates a Pipeline for execution with specific inputs, outputs, and execution parameters.
  • TaskRun: Execution of a task with one or more steps. Instantiates a Task for execution with specific inputs, outputs, and execution parameters. It can be invoked on its own or as part of a Pipeline.

Tekton Tasks

A Task is made up of several Steps that you define and arrange in a particular order of execution as part of your continuous integration flow. Within your Kubernetes cluster, a Task runs as a Pod. A Task is accessible only within a particular namespace, whereas a ClusterTask is accessible throughout the entire cluster.

A task is a set of actions performed in that order. Each step of a task that Tekton executes takes the form of a running container in a Kubernetes pod. A shared environment for several related steps is made possible by this design.

A Task declaration includes the following elements:

  • Parameters
  • Steps
  • Workspaces
  • Results

Example of Tekton Task :

1 apiVersion:

2 kind: Task

3 metadata:

4   name: example-task-name

5 spec:

6   params:

7     – name: pathToDockerFile

8       type: string

9       description: The path to the dockerfile to build

10       default: /workspace/workspace/Dockerfile

11   resources:

12     inputs:

13       – name: workspace

14         type: git

15     outputs:

16       – name: builtImage

17         type: image

18   steps:

19     – name: ubuntu-example

20       image: ubuntu

21       args: [“ubuntu-build-example”, “”]

22     – image:

23       command: [“echo”]

24       args: [“$(params.pathToDockerFile)”]

25     – name: dockerfile-pushexample

26       image:

27       args: [“push”, “$(resources.outputs.builtImage.url)”]

28       volumeMounts:

29         – name: docker-socket-example

30           mountPath: /var/run/docker.sock

31   volumes:

32     – name: example-volume

33       emptyDir: {}

Tekton Pipelines

Tekton Pipelines are an open source project for configuring and running Continuous Integration and Continuous Delivery pipelines within a Kubernetes cluster. It Defines a series of Tasks that accomplish a specific build or delivery goal, which can be triggered by an event or invoked from a PipelineRun. Pipelines in Tekton are defined in YAML files, typically kept in a Git repository. Using a Pipeline, we can run multiple Tasks together in a user-defined sequence or order.

structure of a pipeline


Example of a pipeline :

1 apiVersion:

2 kind: Pipeline

3 metadata:

4   name: svc-deploy-sample

5 spec:

6   params:

7     – name: contextDir

8      description: the context directory from where to build the application

9     – name: destinationImage

10       description: the fully qualified image name

11     – name: storageDriver

12       description: Use storage driver type vfs if you are running on OpenShift.

13       type: string

14      default: vfs

15   workspaces:

16    – name: workspace

17   tasks:

18    – name: build-app

19       taskRef:

20         name: build-app

21       workspaces:

22         – name: source

23           workspace: workspace

24       params:

25         – name: contextDir

26           value: $(params.contextDir) 

27         – name: destinationImage

28           value: $(params.destinationImage)

29         – name: storageDriver

30           value: $(params.storageDriver)

31     – name: deploy-kubernetes-service

32       runAfter:

33         – build-app

34       params:

35         – name: SCRIPT

36           value: |

37             kubectl create deployment greeter –port=8080 –image=$(params.destinationImage)

38             kubectl expose deployment/greeter –port=8080 –target-port=8080 –type=NodePort

How Tekton works:


  • Tekton natively handles Pipelines and Tasks by specifying them as custom resources in a Kubernetes cluster.
  • Tekton Pipelines function by wrapping each of the steps. It does so by injecting an entry point binary in step containers, which executes the command we specify when the system is ready.
  • The entry point binary watches the projected files closely and will only start the provided command if a specific annotation appears as files.
  • Tekton collects all the tasks, connects them in a directed acyclic graph (DAG), and executes the graph in sequence. This means that it creates a number of Kubernetes pods and ensures that each pod is running successfully. Tekton grants developers complete control of the process.

Tekton is an open-source framework for building Continuous Integration/Continuous Delivery systems across cloud providers and on-premises environments. It gives programmers a declarative method for defining, versioning, and sharing intricate CI/CD workflows as code, empowering them to easily automate the creation, testing, and deployment of their applications. However, other CI/CD platforms may present difficulties for developers due to their constrained capabilities and flexibility.

The Challenges Faced on most other platforms: 

  • Only Allow for a one-to-one mapping of pipelines/stages 
  • No templating of tasks and pipelines to use and build on top of.
  • No visual editor for pipelines and tasks
  • No implementation of the app of apps to releases with different pipelines running on different clusters and environments.
  • No catalog of Tasks and Pipelines to re-use

While Tekton aims to address the limitations of other platforms by providing a more flexible Kubernetes-native framework for building and managing pipelines, the Ozone Pipeline Studio goes above and beyond by offering a complete solution that streamlines the entire pipeline development process.

Extending Tekton with the Ozone Pipeline Studio

  • Ozone Studio is an infinite auto-scaling canvas with the fit-to-screen functionality to rearrange tasks on the canvas for a neater view.
  • Ozone Studio internally leverages Tekton Framework for implementing tasks and pipelines and a custom resource to implement Releases.
  • Visual Mode of the Ozone pipeline studio utilizes Scalable Vector Graphic(SVG) to allow for interaction with the canvas, along with ensuring an efficient and fast visual experience.
  • Ozone Studio Runs on a DAG workflow with visualizations to improve user experience; it allows for the connection of multiple tasks enabling one-to-many connections and parallel tasks/pipelines.
  • There’s a toggle between visual and YAML mode, the latter allowing developers to work on the code within the UI with changes updated in the visual mode. 
  • Ozone Allows to specify a YAML and automatically visualize the same, be it for a task, pipeline, or release.
  • Allows to pick and edit from a catalog of tasks or create one from scratch and use these tasks inside the pipelines.
  • Ozone Pipeline Studio’s Out of the box  feature is the availability of task templates from Tekton (community-supported task templates) which cover every major CI/CD use-case. The templates can also be cloned and customized if needed. 

Sample Pipeline in Visual Mode

Sample Pipeline in YAML mode

What Sets Ozone Studio Apart :

1. Parallel Executions of Chains

2. One to Many mapping of Task and Pipelines

3. Catalog of 100+ task and Pipelines templates

Catalog of tasks based on stages within CI/CD

5. Input Parameter mapping through Result passing

6.Fit-to-screen functionality to rearrange tasks automatically and best fit them on the canvas, and Infinite Canvas with Keyboard, Mouse functionalities and Zoom-in/out features

7.  Edit of tasks on canvas

8. Parameterised inputs that make the pipeline generic. There’s support for dynamic secret injections through variables. 

9.Pipeline Status Monitoring through UI :

Task and step-level run view and logs

Release Management on Ozone

When a major app update or bug fixes need to be pushed, a workflow of releasing them is undertaken which typically consists of deploying numerous microservices. While the traditional approach would be to code the pipelines and run them in unison, managing a release becomes quite challenging. 

This is where teams can leverage the Ozone Pipeline Studio to drag, drop, and connect multiple pipelines and deploy the whole release akin to deploying a major app made of multiple smaller applications. Hence the term “app-of-apps”. 

On Ozone, teams can build a workflow of multiple pipelines and run on separate environments, microservices, and the clusters where they are deployed.

Additionally, scans and approvals can also be configured to run in parallel based on the use-case. 

For Example, Ozone Enable use cases such as this to be implemented through releases :

  • Have a build and deploy stage for multiple microservices followed by automation test cases running on the ‘ dev ’ cluster as a pipeline
  • This can be followed by a deploy pipeline on another environment, ‘Staging,’ upon which it can be sent to an approval step 
  • Post the approval step, and deploy all the microservices on the “production” environment.

As can be seen from this blog, the combination of Tekton’s Kubernetes-native capabilities along with Ozone’s low-code approach and added functionalities, go a long way towards streamlining pipeline management. Get on a free trial now to find out how best the platform can address your requirements. 

Ozone is focused on eliminating every complexity of a DevOps team. It simplifies and automates containerized and decentralised application deployments across hybrid cloud and diverse blockchain networks. Ozone integrates seamlessly with major tools across CI, CD, analytics and automation to support your software delivery end to end for even the most complex scenarios.

Write to us at [email protected]

Let’s Connect

Either fill out the form with your enquiry or write to us at [email protected] We will take care of the rest.