The appearance of containers and their performance benefits compared to the existing paradigm of virtual machines has forced several companies to rethink their software lifecycle, especially the delivery part. Continuous integration and deployment tools (CI/CD) are passing through a second renaissance phase which is characterized by new approaches centered around short-lived environments that are launched and destroyed in a much more dynamic way.
In this blog post, we will examine the capabilities of Spinnaker and contrast it with Codefresh, the continuous delivery platform for Kubernetes.
Spinnaker is a multi-cloud deployment solution, originally created by Netflix and then open-sourced in 2015. Today it is actively developed by contributors from other companies such as Google and Target and in 2017 it reached version 1.0.
Codefresh has full CI support, Spinnaker needs Jenkins for CI
This is probably the most important point to understand when you evaluate Spinnaker. Spinnaker handles only the cloud deployment part of the continuous delivery process. Spinnaker does not compile code, does not run any tests and in general is not a generic task runner. To accomplish these tasks it calls Jenkins behind the scenes using the official Jenkins API. Therefore a solution based on Spinnaker essentially requires a Jenkins installation as well.
Codefresh on the other hand is a complete CI/CD solution handling all aspects of the software lifecycle from the moment a commit is created until it is deployed to production. Codefresh has all the capabilities that you would expect from a CI platform such as
- code compilation
- artifact packaging
- testing (unit, integration, acceptance etc.)
- branch management
- pull request handling
All these features are natively supported in Codefresh, while Spinnaker offers no support for them. Essentially Spinnaker is centered around the CD part of a pipeline, while Codefresh takes care of both CI and CD. This can be better visualized with the typical pipeline steps below:
The image shows the typical project pipeline where a code commit creates a Docker image, that then passes unit tests and is deployed to a staging environment. Integration/acceptance tests are then executed and if everything is ok the code change is sent to production.
Codefresh is a single solution that implements the whole pipeline from start to finish. Spinnaker handles only the deployment parts while the actual code compilation and testing is delegated to Jenkins tasks.
You should now see why Spinnaker and Codefresh cannot be directly compared. Codefresh offers a superset of what Spinnaker is offering as far as CI capabilities are concerned. The comparison is really between Spinnaker plus Jenkins, versus Codefresh.
In summary, Codefresh is a complete CI/CD solution, while Spinnaker is a CD solution tool delegating CI to Jenkins.
Spinnaker and Codefresh installation options
Codefresh offers 3 installation choices
- Hosted version
- Hybrid version
- On-premises version
The hosted version is fully managed (SAAS) and is the easiest way to start using Codefresh, as your company does not need to maintain and upgrade Codefresh. This is also the perfect choice if you are a startup and want to start using CI/CD as fast as possible.
Codefresh also offers a hybrid solution where the management UI is in the cloud, but the work machines that compile, build and deploy code exist within the company premises. This is a very powerful option as it allows somebody to completely customize the build machines but keep the User Interface on the cloud version.
It is the ideal installation for companies that have to follow specific regulations (e.g. healthcare and financial institutions) but don’t want to be burdened with the management of a full installation of the platform. This has been proven one of the most popular installation options as it effectively helps companies with secure software delivery and minimal maintenance.
For companies that wish to have full control over everything, Codefresh also offers an on-premises version. This can be installed in your company datacenter or private cloud and is fully managed by the customer.
The important thing regarding these installation options is the amount of flexibility when it comes to Codefresh usage. You can start with the SAAS version and move to the hybrid one with minimal migration. Codefresh can be easily used by a single consultant or a Fortune 500 company or anything in between.
Spinnaker is only offered in a self-hosted manner. There is no SAAS version of Spinnaker that has reached general availability at the time of writing . This means that any organization that wishes to use Spinnaker must invest in manpower responsible for the daily needs and maintenance of the Spinnaker installation itself. This requires an upfront investment from Spinnaker users that may not be always possible or desirable.
Spinnaker itself is composed of multiple micro-services that can be upgraded individually. Installing Spinnaker is a non-trivial process given the fact that a separate application (called Halyard) was also introduced to serve as the Spinnaker installer.
In summary, Spinnaker requires in-house expertise to install and maintain right from the beginning. Codefresh offers a more gradual (and flexible approach) that doesn’t require an upfront investment. The hybrid installation of Codefresh is particularly powerful as it embodies the perfect combination of security and flexibility.
Docker support in Codefresh and Spinnaker
Codefresh has embraced Docker support right from its inception. All Codefresh capabilities revolve around Docker images. Codefresh is especially powerful when it comes to creating Docker images (Docker as a service), annotating them and storing them for later usage.
Spinnaker was created with the old philosophy of creating complete VM images instead of lightweight Docker containers. The basic paradigm of creating a release in Spinnaker is merging a complete VM (e.g. an AMI) with an application in rpm or deb format (a process called “baking” in Spinnaker parlance).
That being said, Spinnaker can work with Docker images as well. This functionality was later retrofitted into Spinnaker and it is not as flexible as what Codefresh offers.
As a starting step, Codefresh offers a built-in Docker dashboard in the basic service. This Docker dashboard allows you to see all container images (from all connected registries) produced by Docker builds. You can then use this dashboard to promote images to any other registry if you desire.
The dashboard comes with various filtering and searching options:
This means that Codefresh offers full traceability as you look at your Kubernetes/Helm dashboards (explained in the next section), see what container images are deployed, click on a container image, see its details, metadata and which pipeline created it.
With Codefresh you can follow a single release from Git commit to Kubernetes deployment from a single application.
Spinnaker has no special support for viewing and auditing docker images, so a Spinnaker solution would need an external container registry dashboard in order to fully function (we have already seen that Spinnaker requires Jenkins, so you might start seeing a pattern here on what Codefresh offers in a single service).
This means that if you want to follow the journey of a single release with Spinnaker you need to visit at least 3 applications (Jenkins, external Docker registry UI, Spinnaker UI). It is up to you to correlate manually all information between the 3 applications and track the deployment process.
Also, the fact that Codefresh has dedicated Docker support right from the beginning is evident from all the tools that it offers. Here are some examples.
The picture above shows the analysis of Docker layers for a container that Codefresh offers. This allows you to inspect the sizes of Docker images and fine-tune the order of the steps found in a Dockerfile.
The picture above shows the annotation support of Codefresh. You can assign custom tags to Docker images in a manual or automatic way. For example, you could mark docker images that have passed integration tests or are compliant with security scanning tools.
In summary, Codefresh has superior and explicit support for Docker images. Spinnaker has only basic Docker support in the form of deploying Docker images but offers nothing additional for managing them.
In a similar manner to Docker, Codefresh comes with dedicated support for Kubernetes deployments. Codefresh offers an explicit Kubernetes deployment step that can be used in a pipeline to deploy a docker image to any Kubernetes cluster regardless of its underlying implementation (Google, Azure etc).
Codefresh also offers a graphical way to manage a Kubernetes cluster with everything that you would expect, such as support for namespaces.
With Spinnaker, things are not so straight-forward. First of all, getting “Kubernetes support” in Spinnaker was not a straightforward process . There are actually two implementations.
- Spinnaker K8s provider version 1 (the old way – now legacy)
- Spinnaker K8s provider version 2 (the new way)
Version 1 of the Spinnaker provider was treating a Kubernetes cluster as another “cloud”. This resulted in a consistent experience for teams that were deploying both VMs and Docker containers via Spinnaker, but on the other hand, could not support the special characteristics that K8s clusters have. This Spinnaker provider is now marked as “Legacy”.
Version 2 of the Spinnaker provider is now the preferred way. This provider treats Kubernetes manifests as artifacts and deploys them on a K8s cluster as any other artifact.
In the end, however, both providers are limited by the fact that Spinnaker is a generic multi-cloud deployment tool and Kubernetes support was “shoehorned” in as Kubernetes is quickly becoming the de-facto clustering solution.
The Spinnaker model is very rigid and the provider does its best to combine Kubernetes concepts to Spinnaker concepts:
- Server Groups ≈ Workloads
- Load Balancers ≈ Services, Ingresses
- Firewalls ≈ NetworkPolicies
The end result is a very complex and obscure configuration. You need to learn how Spinnaker treats configmaps, container image changes, annotation labels and so on before you can understand what exactly happens during a deployment.
Codefresh, on the other hand, was designed with explicit Kubernetes support, free from the old way of deploying VMs, so it is easier to exploit specific Kubernetes features both during build time and during runtime.
Codefresh supports multiple ways of Kubernetes deployment from the built-in deploy step, to custom kubectl commands and even GitOps deployments. There is no “Codefresh specific” knowledge that you must understand before deploying to Kubernetes.
Helm is a package manager for Kubernetes and is quickly becoming the preferred way to deploy K8s applications. It can group associated application services in packages (called Charts) and can also version and rollback application deployments, making releases much less painful.
Helm is another area where Codefresh support really shines. Like Kubernetes and Docker, Codefresh has explicit support for Helm repos and deployments. You can see the Helm releases from within the Codefresh UI as well as browse the available Helm Charts.
The Helm UI is so powerful that you can use it to easily rollback to previous versions of an application. Again this is possible because Codefresh is fully aware about the connection between application, builds, docker images and helm releases.
Codefresh also started offering an integrated Helm repository with each account. This Helm repository is offered for free and like the container dashboard it can help your team quickly get up to speed with Helm using Codefresh as an all-in-one solution.
Specifically for Helm there is a dedicated graphical dashboard that allows you to promote Helm releases between different environments.
Spinnaker has very limited support for Helm. In fact, Helm usage in Spinnaker is just another “baking” stage that uses Helm as a simple templating mechanism (similar to Kustomize). There is no other support for viewing individual Helm releases, promoting them, rolling them back etc. And for storing Helm charts with Spinnaker again you need to choose an external solution.
You can now see the pattern of how Codefresh is an one-stop-shop for your deployments:
With Spinnaker on the other hand you need multiple components to achieve the same thing. Apart from Jenkins you also need to select other solutions that will help manage container images and Kubernetes/Helm releases
In summary, Codefresh gives you everything you need to start with Kubernetes/Helm deployments. With Spinnaker you only get the basic Kubernetes deployment support and you need additional components for the full software lifecycle.
By now it should be clear that if you wish to deploy to Kubernetes/Helm and get a single solution for all your CI/CD needs, Codefresh is a superior turn-key solution.
That does not mean that Spinnaker is a bad choice in general. The truth is that Spinnaker has a different scope than Codefresh. Rather then being targeted at Kubernetes/Helm, Spinnaker is a generic deployment tool that attempts to give a consistent way of deploying to multiple clouds.
The big advantage of Spinnaker is that if your company is deploying VM’s to different cloud providers at the same time (e.g. Google and Azure and AWS and Openstack), you can get a common experience through the Spinnaker UI. On the other hand, because Spinnaker needs to present a common view for all cloud providers, it is hard to expose characteristics that are unique to each one (as it happens in the case of Kubernetes).
Codefresh can also deploy to non-Kubernetes environments, but you would need different yml configurations for each one so some manual work is involved.
Another big advantage of Spinnaker is that is has built-in release strategies such as canaries and blue/green deployments that are offered in a similar manner to all cloud providers. Codefresh also supports blue/green deployments and canaries, but of course, these are implemented for Kubernetes and would need changes for deploying VM’s to other cloud providers.
Therefore if your company is not interested in Kubernetes/Helm and you still need to deploy VM’s to more than one cloud providers at the same time, Spinnaker is a very obvious contender.
Spinnaker and Codefresh could work together
It is important to notice that Spinnaker and Codefresh could potentially work together. The Jenkins support found in Spinnaker is just a plugin. In theory, one could also write a similar plugin for Codefresh. This way Spinnaker could be used for CD while delegating all CI tasks to Codefresh.
It is arguable whether this approach is practical or not, but it is useful to know that a team that has the resources and time to write such plugin could make both tools work together.
If you are looking for the easiest way to start deploying applications to Kubernetes/Helm then Codefresh is the obvious choice. Codefresh
- has excellent CI support (branching/merging, unit tests, pull requests etc)
- has built-in support for building Docker images (docker as a service)
- has an integrated dashboard for managing container images
- has a dedicated management UI for your Kubernetes cluster with full view of namespaces/pods/services etc.
- has an integrated Helm repository
- has full support for performing Helm releases and rolling them back
- can be used in a hosted/on-prem/hybrid manner allowing you to start right away
Spinnaker on the other hand can be a better solution if
- You have a heavy investment on existing Jenkins jobs that you do not wish to deprecate
- You are not interested in Kubernetes/Helm and only want to deploy full blown VM images
- You are deploying VMs to multiple clouds at the same time (Azure, AWS, Google etc) and wish to use a common interface for the deployment strategies
- You have an in-house team that will be responsible for installing/upgrading Spinnaker and you can dedicate resources to its on-going maintenance
Hope, you find this post useful. I look forward to your comments and any questions you have. To try this out, create a free Codefresh account and start building, testing and deploying Docker images faster than ever.