What's in a name? wrote the greatest Bard that ever lived.
He was wrong. If someone ever asked me a hypothetical question about which dead person I'd want to have a conversation with, it'll definitely be Shakespeare. Let me explain why.
When we launched Shippable Pipelines last year, we wanted to highlight the difference between plain vanilla CI and the capability to put together a deployment "pipeline" that spans orchestration across multiple environments and supports all tasks involved in software delivery like CI, infrastructure provisioning, test automation, deployments, security patching, release management, config mgmt, service discovery, etc.
However, shortly after we launched, other CI providers launched their own interpretations of "pipelines"! For example,
How did everyone come to the same exact place so rapidly? As we found out, they didn't. Pipelines was being used as a fancy name for CI, with features that Shippable had supported for over two years, like Matrix builds for splitting tests or testing against multiple environments for example.
We needed a way to explain why Shippable is different. This blog explains why we landed on DevOps Assembly Lines as the perfect way to describe our approach to DevOps and CI/CD.
What are CI pipelines?
Continuous Integration has evolved tremendously over the last few years. What started as a simple process of automating build and unit tests for each code change has evolved into a pretty complex workflow.
As an example, look at the different CI workflows shown below:
In Classic CI, all build and test instructions were included in a single blob and instructions were executed serially. If all instructions executed successfully, CI was succesful, and if anything failed, then it was marked failed. Almost all CI providers, until recently, offered just classic CI.
However, as CI became mainstream, developers wanted to define more complex workflows with decision trees and parallelism. CI pipelines support this complexity, such as:
- Defining the CI workflow in stages, so you can get results from a stage faster without having to wait for the entire workflow to finish.
- Running stages in parallel, so you can split tests or test your code against different environments or language versions, and get faster feedback.
- Forking your CI logic based on the results of a stage.
While CI pipelines are a huge improvement over Classic CI, they are still limited to developer-focused workflows.
What are DevOps Assembly Lines?
DevOps Assembly Lines are focused on automating and connecting activities performed by several teams, such as CI for devs, infrastructure provisioning and config mgmt for Ops, test automation for Test, security patching for SecOps, semantic versioning and approval gates for Release Managers, deployments for multiple environments, and so on.
Today, most organizations use various tools for automating specific DevOps activities. However, the DevOps toolchain is fragmented and glueing it together to achieve Continuous Delivery is a challenging task.
Most teams adopt one of the following approaches:
- Using cultural collaboration as the glue between silos. As an example, when a new application version is available, the Test team creates a JIRA ticket and assigns to Ops. Ops then copies the application version information into their deployment scripts and run them.
- Writing ad-hoc scripts to trigger one activity from another, including passing state information through intermediate storage like S3. In this case, the DevOps engineer would likely write a Jenkins job which runs automated tests, and then pushes application version information to S3. Another Jenkins job polls the S3 bucket, and when a change is detected, runs the deployment scripts.
The first approach introduces inefficiency and unnecessary human-dependent steps. The second approach is better, but only works well for small teams working on a single application. It creates a frankenstein of spagetti automation when you have many applications or even a single application with microservices.
DevOps Assembly Lines address this problem by focusing on glueing together these various DevOps activities into streamlined, event-driven workflows with the ability to easily share state and other information across activities.
The following image shows a typical Assembly Line for a single application or service:
See the difference? The CI pipeline is just ONE activity in the Assembly Line. Each of the boxes in the picture above is a pipeline, just for different activities! Each has specific needs with respect to tools integration, runtime, configuration, notifications, etc. In addition, each pipeline is owned by a different team, yet needs to interact with other pipelines and exchange information. For example, if the Ops team changes provisioning scripts for Staging environment, the Test team need to redeploy the application and run performance tests.
A DevOps Assembly Line is therefore a "Pipeline of Pipelines".
DevOps Assembly Lines therefore need to support the following:
- Ability to easily define workflows across multiple pipelines.
- Versioned and reusable workflows, enabling rapid changes and scaling for multiple applications and/or microservices
- Integrations with all popular source control systems, clouds, artifact repositories, DevOps tools, languages, services, etc
- Runtime to execute every pipeline, including pre-installed tools and CLIs, and the ability to use the right runtime, depending on pipeline type
- Accelerators/playbooks for common pipelines and tools
- Ability to pass state and other information while triggering dependent pipelines
- Automatic triggers or manual approval gates between each pipeline
- Configurable notifications for each stage of every pipeline
- Release automation features like semantic versioning of packages
- Audit trails for each pipeline, with the ability to go back or forward to a specific state
- Abstraction of all sensitive information like passwords, tokens, keys, etc for security reasons
- Roles and permissions restricting Assembly Line and pipeline actions
- Manage DevOps infrastructure, including spinning VMs and containers up and down as required
- Visibility into each pipeline and stage, including logs, status, and versioned data
- Metrics and Analytics across pipelines to help identify bottlenecks
DevOps Assembly Lines help automate end-to-end workflows across all teams and tools, enabling Continuous Delivery.
For a deeper look at Assembly Lines, download our whitepaper: