Skip to main content
Redhat Developers  Logo
  • Products

    Platforms

    • Red Hat Enterprise Linux
      Red Hat Enterprise Linux Icon
    • Red Hat AI
      Red Hat AI
    • Red Hat OpenShift
      Openshift icon
    • Red Hat Ansible Automation Platform
      Ansible icon
    • View All Red Hat Products

    Featured

    • Red Hat build of OpenJDK
    • Red Hat Developer Hub
    • Red Hat JBoss Enterprise Application Platform
    • Red Hat OpenShift Dev Spaces
    • Red Hat OpenShift Local
    • Red Hat Developer Sandbox

      Try Red Hat products and technologies without setup or configuration fees for 30 days with this shared Openshift and Kubernetes cluster.
    • Try at no cost
  • Technologies

    Featured

    • AI/ML
      AI/ML Icon
    • Linux
      Linux Icon
    • Kubernetes
      Cloud icon
    • Automation
      Automation Icon showing arrows moving in a circle around a gear
    • View All Technologies
    • Programming Languages & Frameworks

      • Java
      • Python
      • JavaScript
    • System Design & Architecture

      • Red Hat architecture and design patterns
      • Microservices
      • Event-Driven Architecture
      • Databases
    • Developer Productivity

      • Developer productivity
      • Developer Tools
      • GitOps
    • Automated Data Processing

      • AI/ML
      • Data Science
      • Apache Kafka on Kubernetes
    • Platform Engineering

      • DevOps
      • DevSecOps
      • Ansible automation for applications and services
    • Secure Development & Architectures

      • Security
      • Secure coding
  • Learn

    Featured

    • Kubernetes & Cloud Native
      Openshift icon
    • Linux
      Rhel icon
    • Automation
      Ansible cloud icon
    • AI/ML
      AI/ML Icon
    • View All Learning Resources

    E-Books

    • GitOps Cookbook
    • Podman in Action
    • Kubernetes Operators
    • The Path to GitOps
    • View All E-books

    Cheat Sheets

    • Linux Commands
    • Bash Commands
    • Git
    • systemd Commands
    • View All Cheat Sheets

    Documentation

    • Product Documentation
    • API Catalog
    • Legacy Documentation
  • Developer Sandbox

    Developer Sandbox

    • Access Red Hat’s products and technologies without setup or configuration, and start developing quicker than ever before with our new, no-cost sandbox environments.
    • Explore Developer Sandbox

    Featured Developer Sandbox activities

    • Get started with your Developer Sandbox
    • OpenShift virtualization and application modernization using the Developer Sandbox
    • Explore all Developer Sandbox activities

    Ready to start developing apps?

    • Try at no cost
  • Blog
  • Events
  • Videos

Building a Continuous Deployment Engine

May 21, 2014
Jen Krieger
Related topics:
DevOps
Related products:
Developer Tools

Share:

    A couple of weeks ago, I mentioned that we (the Red Hat Inception Team) are building "a thing."  Given our own internal interest in the topic, you may be wondering why we chose a custom Release Engine over pre-baked tooling. There are many different reasons why we went in this direction; I'm going to cover four.

    Why #1: There are many existing FOSS tools to automate portions of a release process, but there seems to be a tooling gap in tying them easily together.

    For CI, there's Jenkins/Hudson, buildbot, Travis, etc..; for configuration management, Chef or Puppet; for repository management, Pulp or Satellite; for provisioning, Foreman, Satellite, or Cobbler; for host scripting, Ansible as well as our own Taboot. In Red Hat IT, we're using at least one of these tools in each category. But, there seems to be a lack of easy to use tools to automate orchestration across these systems. Yes, Jenkins can tie them all together, but it's not easy to set up and even harder to maintain. The Release Engine (RE) is our stab at solving this problem.

    Why #2: RE must be light-weight and fit to purpose.

    This doesn't mean that our Release Engine efforts will be restricted to our use cases only, we are trying to make it generic enough that it is reusable by others outside of Red Hat.

    Additionally, we already have a few general purpose workflow engines at our fingertips, but we chose not to use them. To be successful, we believe that RE must be easy to extend and modify by our development and operations team members. Each specific workflow tool comes with their own difficulties for making them accessible to the entire department. For example, the prerequisite to set up an Eclipse IDE for a sysadmin to add a new release step would render RE dead on arrival.

    In the words of Anderson Silva, the manager of our NA & EMEA Platform Operations team, "the key to the success of this engine is not how many things it can do when it gets released, but how easily people can add functionality to it as demand grows."

    Why #3: RE must be written in a commonly known language. See Why #2.

    We chose Python. It's a popular interpreted language, easy to read and modify and one in which both our development and operations folks frequently have experience. A system that requires Java, C, C++, Mono, etc. to extend would severely limit its accessibility to team members outside the development side of the house, as well as those developers who don't have time to spend writing traditional strongly typed/compiled code to get their functionality implemented.

    Why #4: We need to support a model of decentralized CI, so RE will do the work necessary to maintain a reliable, repeatable and auditable release.  

    We will go into the details behind this in the future, but we have already tried centralized CI. As we grew, it became apparent it wasn't going to continue working for everyone in our department. Developers wanted more control over their CI and having it centralized didn't give much support to that desire. So, we are trying to unwind our centralized CI tool in favor of developer supported CI environments. No matter what CI solution a team chooses, it should easily hook into RE.

    For practical purposes we need consistency in releases and since we won't be driving that through a central CI system, the release engine will have that job instead. It was unclear that any one tool would what we needed while also doing the following:

    1. Who is doing the release and are they allowed to modify that environment/code/thing? We are all about empowerment, but we're only going to let people push their team's code... and definitely not to all environments without fulfilling some prerequisites.
    2. When did the release occur and is it allowed to occur at that time? Sometimes, you need to coordinate code releases so they don't completely blow up critical business processes. You may say "that's not CD" - I say; reality of being in an enterprise IT shop. We'll deal with it if and when we need to.
    3. What and how are you actually deploying? Got a special little thing you do over here in this environment because of "reasons?" Not a thing anymore! We want deployments to be repeatable by everyone, including me... The Product Owner. :)

    Interested in some of the tools we reviewed?
    Here are four we looked at with some thoughts from the team. Kudos to the creators and maintainers of the code; they helped guide some of our design decisions along the way.

    Deployinator
    What what we like:

    • Language/Framework is Ruby/Rails which many people know.
    • Reusable classes for releases is a good idea.

    Why we didn’t choose it:

    • Not a lot of current code updates.
    • README was noted as out of date.
    • Seems to be designed more around checking out code and putting it somewhere which wouldn’t work for us.
    • The authentication seems to be implemented to an in-house system.

    Dreadnot
    What what we like:

    • Language/Framework is Javascript/Node.js. Almost every engineer knows Javascript.
    • Feature enhancements added within the last few months showing it’s still active.
    • Runs asynchronous.

    Why we didn’t choose it:

    • There seems to be regions called out in configs (https://github.com/racker/dreadnot/blob/master/example/local_settings.js#L13) – this may be tied to specific infrastructure.
    • Stacks look like they must be defined and stored on the server side. Another system would need to be in place to support developers modification of deployments.

    Strider
    What what we like:

    • Language/Framework is Javascript/Node.js. Almost every engineer knows Javascript.
    • Under active development.
    • Strider likes to take common deployment scenarios and make them into reusable recipes.
    • Having reusable stuff is much better than having everyone have custom stuff that ends up to be 95% the same.

    Why we didn’t choose it

    • The actual server and runners are all on one machine.
    • It doesn’t seem to delegate out unless you install and configure extensions.
    • Seems to be CI with CD added to it.

    Thoughworks – Go
    What what we like:

    • Good Flow layout and visualizations
    • Out of the box LDAP integration

    Why we didn’t choose it

    • Language is Java, JRuby. While JRuby would be easy for developers the need to add Java + JRuby libraries seems like overkill.
    • Source code was unavailable. (The product was only recently open sourced and is now available).
    • This appears to be a full on replacement for Jenkins and not a system that would run along side of it.
    • Not pluggable as far as we could tell, though we never tried to set up a server as the code was unavailable at that time.
    • The LDAP setup is a bunch of XML and it is unclear whether there is an easy way to use the the GUI to update users.
    Last updated: February 7, 2024

    Recent Posts

    • Migrating Ansible Automation Platform 2.4 to 2.5

    • Multicluster resiliency with global load balancing and mesh federation

    • Simplify local prototyping with Camel JBang infrastructure

    • Smart deployments at scale: Leveraging ApplicationSets and Helm with cluster labels in Red Hat Advanced Cluster Management for Kubernetes

    • How to verify container signatures in disconnected OpenShift

    Red Hat Developers logo LinkedIn YouTube Twitter Facebook

    Products

    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform

    Build

    • Developer Sandbox
    • Developer Tools
    • Interactive Tutorials
    • API Catalog

    Quicklinks

    • Learning Resources
    • E-books
    • Cheat Sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site Status Dashboard
    • Report a security problem

    RED HAT DEVELOPER

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2025 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility

    Report a website issue