A common problem faced by most developers is how to release the implemented code quickly and safely. The delivery process used traditionally is a source of pitfalls and usually leads to the disappointment of both developers and clients. This chapter presents the idea of the Continuous Delivery (CD) approach and provides the context for the rest of the book.
This chapter covers the following points:
- Understanding CD
- The automated deployment pipeline
- Prerequisites to CD
- Building the CD process
- Creating a complete CD system
The most accurate definition of the CD is stated by Jez Humble and reads as follows:
"Continuous Delivery is the ability to get changes of all types—including new features, configuration changes, bug fixes, and experiments—into production, or into the hands of users, safely and quickly, in a sustainable way."
This definition covers the key points.
To understand it better, let's imagine a scenario. You are responsible for a product, let's say, the email client application. Users come to you with a new requirement: they want to sort emails by size. You decide that the development will take around one week. When can the user expect to use the feature? Usually, after the development is done, you hand over the completed feature first to the QA team and then to the operations team, which takes additional time, ranging from days to months.
Therefore, even though the development took only one week, the user receives it in a couple of months! The CD approach addresses that issue by automating manual tasks so that the user could receive a new feature as soon as it's implemented.
To help you to understand what to automate and how, let's start by describing the delivery process that is currently used for most software systems.
Any delivery process begins with the requirements defined by a customer and ends up with release on production. The differences are in-between. Traditionally, it looks as presented in the following release cycle diagram:
The release cycle starts with the requirements provided by the Product Owner, who represents the Customer (stakeholders). Then there are three phases, during which the work is passed between different teams:
- Development: The developers (sometimes together with business analysts) work on the product. They often use Agile techniques (Scrum or Kanban) to increase the development velocity and to improve communication with the client. Demo sessions are organized to obtain a customer's quick feedback. All good development techniques (such as test-driven development or extreme programming practices) are welcome. Once implementation is complete, the code is passed to the QA team.
- Quality Assurance: This phase is usually called User Acceptance Testing (UAT) and it requires a code freeze on the trunk code base, so that no new development would break the tests. The QA team performs a suite of Integration Testing, Acceptance Testing, and Non-functional analysis (performance, recovery, security, and so on). Any bug that is detected goes back to the development team, so developers usually have their hands full. After the UAT phase is completed, the QA team approves the features that are planned for the next release.
- Operations: The final phase, usually the shortest one, means passing the code to the operations team, so that they can perform the release and monitor production. If anything goes wrong, they contact developers to help with the production system.
The length of the release cycle depends on the system and the organization, but it usually ranges from a week to a few months. The longest I've heard about was one year. The longest I worked with was quarterly-based, and each part took as follows: development—1.5 months, UAT—1 month and 3 weeks, release (and strict production monitoring)—1 week.
The traditional delivery process is widely used in the IT industry and it's probably not the first time you've read about such an approach. Nevertheless, it has a number of drawbacks. Let's look at them explicitly to understand why we need to strive for something better.
- Slow delivery: The customer receives the product long after the requirements were specified. This results in unsatisfactory time to market and delays customer feedback.
- Long feedback cycle: The feedback cycle is not only related to customers, but also to developers. Imagine that you accidentally created a bug and you learn about it during the UAT phase. How long does it take to fix something you worked on two months ago? Even dealing with minor bugs can take weeks.
- Lack of automation: Rare releases don't encourage automation, which leads to unpredictable releases.
- Risky hotfixes: Hotfixes can't usually wait for the full UAT phase, so they tend to be tested differently (the UAT phase is shortened) or not tested at all.
- Stress: Unpredictable releases are stressful for the operations team. What's more, the release cycle is usually tightly scheduled, which imposes an additional stress on developers and testers.
- Poor communication: Work passed from one team to another represents the waterfall approach, in which people start to care only about their part, rather than the complete product. In case anything goes wrong, that usually leads to the blame game instead of cooperation.
- Shared responsibility: No team takes responsibility for the product from A to Z:
- For developers: done means that requirements are implemented
- For testers: done means that the code is tested
- For operations: done means that the code is released
- Lower job satisfaction: Each phase is interesting for a different team, but other teams need to support the process. For example, the development phase is interesting for developers but, during the other two phases, they still need to fix bugs and support the release, which usually is not interesting for them at all.
These drawbacks represent just a tip of the iceberg of the challenges related to the traditional delivery process. You may already feel that there must be a better way to develop the software and this better way is, obviously, the CD approach.
How long would it take your organization to deploy a change that involves just a single line of code?Do you do this on a repeatable, reliable basis? These are the famous questions from Mary and Tom Poppendieck (authors of Implementing Lean Software Development), which have been quoted many times by Jez Humble and others. Actually, the answer to these questions is the only valid measurement of the health of your delivery process.
To be able to deliver continuously, and not spend a fortune on the army of operations, teams working 24/7, we need automation. That is why, in short, CD is all about changing each phase of the traditional delivery process into a sequence of scripts, called the automated deployment pipeline, or the CD pipeline. Then, if no manual steps are required, we can run the process after every code change and, therefore, deliver the product continuously to users.
CD lets us get rid of the tedious release cycle and, therefore, brings the following benefits:
- Fast delivery: Time to market is significantly reduced as customers can use the product as soon as development is completed. Remember that the software delivers no revenue until it is in the hands of its users.
- Fast feedback cycle: Imagine you created a bug in the code, which goes into production the same day. How much time does it take to fix something you worked on the same day? Probably not much. This, together with the quick rollback strategy, is the best way to keep the production stable.
- Low-risk releases: If you release on a daily basis, the process becomes repeatable and therefore much safer. As the saying goes, if it hurts, do it more often.
- Flexible release options: In case you need to release immediately, everything is already prepared, so there is no additional time/cost associated with the release decision.
Needless to say, we could achieve all these benefits simply by eliminating all delivery phases and proceeding with development directly on production. It would, however, result in a reduction in the quality. Actually, the whole difficulty of introducing CD is the concern that the quality would decrease together with eliminating manual steps. In this book, we will show you how to approach CD in a safe manner and explain why, contrary to common beliefs, products delivered continuously have fewer bugs and are better adjusted to the customer's needs.
My favorite story on CD was told by Rolf Russell at one of his talks. It goes as follows. In 2005, Yahoo acquired Flickr, and it was a clash of two cultures in the developer's world. Flickr, by that time, was a company with the start-up approach in mind. Yahoo, on the contrary, was a huge corporation with strict rules and a safety-first attitude. Their release processes differed a lot. While Yahoo used the traditional delivery process, Flickr released many times a day. Every change implemented by developers went into production the same day. They even had a footer at the bottom of their page showing the time of the last release and the avatars of the developers who did the changes.
Yahoo deployed rarely, and each release brought a lot of changes that were well-tested and prepared. Flickr worked in very small chunks; each feature was divided into small incremental parts, and each part was deployed to production quickly. The difference is presented in the following diagram:
You can imagine what happened when the developers from the two companies met. Yahoo obviously treated Flickr's colleagues as junior irresponsible developers, a bunch of software cowboys who didn't know what they were doing. So, the first thing they wanted to change was to add a QA team and the UAT phase to Flickr's delivery process. Before they applied the change, however, Flickr's developers had only one wish. They asked to evaluate the most reliable products throughout Yahoo as a whole. What a surprise when it happened that of all the software in Yahoo, Flickr had the lowest downtime. The Yahoo team didn't understand it at first, but let Flickr stay with their current process anyway. After all, they were engineers, so the evaluation result was conclusive. Only after some time had passed did the Yahoo developers realize that the CD process could be beneficial for all products in Yahoo and they started to gradually introduce it everywhere.
The most important question of the story remains: how was it possible that Flickr was the most reliable system? Actually, the reason behind that fact was what we already mentioned in the previous sections. A release is less risky if the following is true:
- The delta of code changes is small
- The process is repeatable
That is why, even though the release itself is a difficult activity, it is much safer when done frequently.
The story of Yahoo and Flickr is only one example of many successful companies for which the CD process proved to be the correct choice. Some of them even proudly share details from their systems, as follows:
- Amazon: In 2011, they announced reaching 11.6 seconds (on average) between deployments
- Facebook: In 2013, they announced deployment of code changes twice a day
- HubSpot: In 2013, they announced deployment 300 times a day
- Atlassian: In 2016, they published a survey stating that 65% of their customers practice CD
You can read more about the research on the CD process and individual case studies at https://continuousdelivery.com/evidence-case-studies/.
Keep in mind that the statistics get better every day. However, even without any numbers, just imagine a world in which every line of code you implement goes safely into production. Clients can react quickly and adjust their requirements, developers are happy because they don't have to solve that many bugs, and managers are satisfied because they always know the current state of work. After all, remember that the only true measure of progress is the software released.
Let's start by emphasizing that each phase in the traditional delivery process is important. Otherwise, it would never have been created in the first place. No one wants to deliver software without testing it first! The role of the UAT phase is to detect bugs and to ensure that what developers created is what the customer wanted. The same applies to the operations team—the software must be configured, deployed to production, and monitored. That's out of the question. So, how do we automate the process so that we preserve all the phases? That is the role of the automated deployment pipeline, which consists of three stages, as presented in the following diagram:
The automated deployment pipeline is a sequence of scripts that is executed after every code change committed to the repository. If the process is successful, it ends up with deployment to the production environment.
- Continuous Integration: This checks to make sure that the code written by different developers is integrated
- Automated Acceptance Testing: This checks if the client's requirements are met by the developers implementing the features. This testing also replaces the manual QA phase.
- Configuration Management: This replaces the manual operations phase; it configures the environment and deploys the software
Let's take a deeper look at each phase to understand its responsibility and what steps it includes.
The CI phase provides the first feedback to developers. It checks out the code from the repository, compiles it, runs unit tests, and verifies the code quality. If any step fails, the pipeline execution is stopped and the first thing the developers should do is fix the CI build. The essential aspect of this phase is time; it must be executed in a timely manner. For example, if this phase took an hour to complete, developers would commit the code faster, which would result in the constantly failing pipeline.
The CI pipeline is usually the starting point. Setting it up is simple because everything is done within the development team, and no agreement with the QA and operations teams is necessary.
The automated acceptance testing phase is a suite of tests written together with the client (and QAs) that is supposed to replace the manual UAT stage. It acts as a quality gate to decide whether a product is ready for release. If any of the acceptance tests fail, pipeline execution is stopped and no further steps are run. It prevents movement to the configuration management phase and, hence, the release.
The whole idea of automating the acceptance phase is to build the quality into the product instead of verifying it later. In other words, when a developer completes the implementation, the software is already delivered together with acceptance tests that verify that the software is what the client wanted. That is a large shift in thinking in relation to testing software. There is no longer a single person (or team) who approves the release, but everything depends on passing the acceptance test suite. That is why creating this phase is usually the most difficult part of the CD process. It requires close cooperation with the client and creating tests at the beginning (not at the end) of the process.
Introducing automated acceptance tests is especially challenging in the case of legacy systems. We discuss this topic in greater detail in Chapter 9, Advanced Continuous Delivery.
There is usually a lot of confusion about the types of tests and their place in the CD process. It's also often unclear as to how to automate each type, what the coverage should be, and what the role of the QA team should be in the development process. Let's clarify it using the Agile testing matrix and the testing pyramid.
Brian Marick, in a series of his blog posts, made a classification of software tests in the form of the agile testing matrix. It places tests in two dimensions—business or technology-facing, and support programmers or a critique of the product. Let's have a look at that classification:
Let's comment briefly on each type of test:
- Acceptance Testing (automated): These are tests that represent functional requirements seen from the business perspective. They are written in the form of stories or examples by clients and developers to agree on how the software should work.
- Unit Testing (automated): These are tests that help developers to provide high-quality software and minimize the number of bugs.
- Exploratory Testing (manual): This is the manual black-box testing, which tries to break or improve the system.
- Non-functional Testing (automated): These are tests that represent system properties related to performance, scalability, security, and so on.
This classification answers one of the most important questions about the CD process: what is the role of a QA in the process?
Manual QAs perform the exploratory testing, so they play with the system, try to break it, ask questions, and think about improvements. Automation QAs help with non-functional and acceptance testing; for example, they write code to support load testing. In general, QAs don't have their special place in the delivery process, but rather a role in the development team.
In the automated CD process, there is no longer a place for manual QAs who perform repetitive tasks.
You may look at the classification and wonder why you see no integration tests there. Where are they up to Brian Marick, and where to put them in the CD pipeline?
To explain it well, we first need to mention that the meaning of an integration test differs depending on the context. For (micro) service architectures, they usually mean exactly the same as acceptance testing, as services are small and need nothing more than unit and acceptance tests. If you build a modular application, then integration tests usually mean component tests that bind multiple modules (but not the whole application) and test them together. In that case, integration tests place themselves somewhere between acceptance and unit tests. They are written in a similar way to acceptance tests, but are usually more technical and require mocking not only external services, but also internal modules. Integration tests, similar to unit tests, represent the code point of view, while acceptance tests represent the user point of view. As regards the CD pipeline, integration tests are simply implemented as a separate phase in the process.
The previous section explained what each test type represents in the process, but mentioned nothing about how many tests we should develop. So, what should the code coverage be in the case of unit testing? What about acceptance testing?
When we move up the pyramid, the tests become slower and more expensive to create. They often require user interfaces to be touched and a separate test automation team to be hired. That is why acceptance tests should not target 100% coverage. On the contrary, they should be feature-oriented and verify only selected test scenarios. Otherwise, we would spend a fortune on test development and maintenance, and our CD pipeline build would take ages to execute.
The case is different at the bottom of the pyramid. Unit tests are cheap and fast, so we should strive for 100% code coverage. They are written by developers, and providing them should be a standard procedure for any mature team.
I hope that the agile testing matrix and the testing pyramid clarified the role and the importance of acceptance testing.
Let's now move to the last phase of the CD process, configuration management.
The configuration management phase is responsible for tracking and controlling changes in the software and its environment. It involves taking care of preparing and installing the necessary tools, scaling the number of service instances and their distribution, infrastructure inventory, and all tasks related to application deployment.
Configuration management is a solution to the problems posed by manually deploying and configuring applications on the production. This common practice results in an issue whereby we no longer know where each service is running and with what properties. Configuration management tools (such as Ansible, Chef, or Puppet) enable us to store configuration files in the version control system and track every change that was made on the production servers.
An additional effort to replace manual tasks of the operation's team is to take care of application monitoring. That is usually done by streaming logs and metrics of the running systems to a common dashboard, which is monitored by developers (or the DevOps team, as explained in the next section).
The rest of this book is dedicated to technical details on how to implement a successful CD pipeline. The success of the process, however, depends not only on the tools we present throughout this book. In this section, we take a holistic look at the whole process and define the CD requirements in three areas:
- Your organization's structure and its impact on the development process
- Your products and their technical details
- Your development team and the practices you adopt
The way your organization works has a high impact on the success of introducing the CD process. It's a bit similar to introducing Scrum. Many organizations would like to use the Agile process, but they don't change their culture. You can't use Scrum in your development team unless the organization's structure is adjusted for that. For example, you need a product owner, stakeholders, and management that understands that no requirement changes are possible during the sprint. Otherwise, even with good intentions, you won't make it. The same applies to the CD process; it requires an adjustment of how the organization is structured. Let's have a look at three aspects: the DevOps culture, a client in the process, and business decisions.
A long time ago, when software was written by individuals or microteams, there was no clear separation between development, quality assurance, and operations. A person developed the code, tested it, and then put it into production. If anything went wrong, the same person investigated the issue, fixed it, and redeployed it to production. The way the development is organized now changed gradually, when systems became larger and development teams grew. Then, engineers started to become specialized in one area. That made perfect sense, because specialization caused a boost in productivity. However, the side-effect was the communication overhead. It is especially visible if developers, QAs, and operations are in separate departments in the organization, sit in different buildings, or are outsourced to different countries. This organizational structure is no good for the CD process. We need something better; we need to adapt the DevOps culture.
DevOps culture means, in a sense, coming back to the roots. A single person or a team is responsible for all three areas, as presented in the following diagram:
The reason it's possible to move to the DevOps model without losing productivity is automation. Most of the tasks related to quality assurance and operations are moved to the automated delivery pipeline and can therefore be managed by the development team.
A DevOps team doesn't necessarily need to consist only of developers. A very common scenario in many organizations under transformation is to create teams with four developers, one QA, and one person from operations. They need, however, to work closely together (sit in one area, have stand-ups together, work on the same product).
The culture of small DevOps teams affects the software architecture. Functional requirements have to be separated into (micro) services or modules, so that each team can take care of an independent part.
The role of a client (or a product owner) changes slightly during CD adoption. Traditionally, clients are involved in defining requirements, answering questions from developers, attending demos, and taking part in the UAT phase to determine whether what was built is what they had in mind.
In CD, there is no UAT, and a client is essential in the process of writing acceptance tests. For some clients, who already wrote their requirements in a testable manner, it is not a big shift. For others, it means a change in their way of thinking to make requirements more technical-oriented.
In most companies, the business has an impact on the release schedule. After all, the decision of what features are delivered, and when, is related to different departments within the company (for example, marketing) and can be strategic for the enterprise. That is why the release scheduling has to be re-approached and discussed between the business and the development teams.
Obviously, there are techniques, such as feature toggles or manual pipeline steps, that help with releasing features at the specified time. We will describe them later in the book. To be precise, the term Continuous Delivery is not the same as Continuous Deployment. The latter means that each commit to the repository is automatically released to production. Continuous Delivery is less strict and means that each commit ends up with a release candidate, so it allows the last step (release to production) to be manual.
- Automated build, test, package, and deploy operations: All operations need to be able to be automated. If we deal with a system that is non-automatable, for example, due to security reasons or its complexity, it's impossible to create a fully automated delivery pipeline.
- Quick pipeline execution: The pipeline must be executed in a timely manner, preferably in 5-15 minutes. If our pipeline execution takes hours or days, it won't be possible to run it after every commit to the repository.
- Quick failure recovery: The possibility of a quick rollback or system recovery is a must. Otherwise, we risk production health due to frequent releases.
- Zero-downtime deployment: The deployment cannot have any downtime since we release many times a day.
- Trunk-based development: Developers must check in regularly into one master branch. Otherwise, if everyone develops in their own branches, integration is rare and therefore the releases are rare, which is exactly the opposite of what we want to achieve.
We will write more on these prerequisites and how to address them throughout the book. Keeping that in mind, let's move to the last section of this chapter and introduce what system we plan to build in this book and what tools we will use for that purpose.
We introduced the idea, benefits, and prerequisites with regard to the CD process. In this section, we will describe the tools that will be used throughout this book and their place in the system as a whole.
If you're interested more in the idea of the CD process, have a look at an excellent book by Jez Humble and David Farley, Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation.
First of all, the specific tool is always less important than understanding its role in the process. In other words, any tool can be replaced with another one that plays the same role. For example, Jenkins can be replaced with Atlassian Bamboo, and Chef can be used instead of Ansible. This is why each chapter begins with the general description of why such a tool is necessary and its role in the whole process. Then, the exact tool is described in comparison to its substitutes. That form gives you the flexibility to choose the right one for your environment.
Another approach could be to describe the CD process on the level of ideas; however, I strongly believe that giving an exact example with the code extract, something that readers can run by themselves, results in a much better understanding of the concept.
There are two ways to read this book. The first is to read and understand the concepts of the CD process. The second is to create your own environment and execute all scripts while reading to understand the details.
Let's have a quick look at the tools we will use throughout this book. This section, however, is only a brief introduction to each technology—much more detail will be presented as this book proceeds.
Docker, as the clear leader of the containerization movement, has dominated the software industry in recent years. It allows us to package an application in the environment-agnostic image and therefore treats servers as a farm of resources, rather than machines that must be configured for each application. Docker was a clear choice for this book because it perfectly fits the (micro) service world and the CD process.
Docker entails a number of additional technologies, which are as follows:
- Docker Hub: This is a registry for Docker images
- Kubernetes: This is a container orchestrator
Jenkins is by far the most popular automation server on the market. It helps to create CI and CD pipelines and, in general, any other automated sequence of scripts. Highly plugin-oriented, it has a great community that constantly extends it with new features. What's more, it allows us to write the pipeline as code and supports distributed build environments.
Ansible is an automation tool that helps with software provisioning, configuration management, and application deployment. It is trending faster than any other configuration management engine and will soon overtake its two main competitors: Chef and Puppet. It uses agentless architecture and integrates smoothly with Docker.
GitHub is definitely the best of all hosted version control systems. It provides a very stable system, a great web-based UI, and a free service for public repositories. Having said that, any source control management service or tool will work with CD, irrespective of whether it's in the cloud or self-hosted, and whether it's based on Git, SVN, Mercurial, or any other tool.
Java has been the most popular programming language for years. That is why it is being used for most code examples in this book. Together with Java, most companies develop with the Spring framework, so we used it to create a simple web service needed to explain some concepts. Gradle is used as a build tool. It's still less popular than Maven, but is, trending much faster. As always, any programming language, framework, or build tool can be exchanged and the CD process would stay the same, so don't worry if your technology stack is different.
The first one is based on the steps of the automated deployment pipeline. Each chapter takes you closer to the complete CD process. If you look at the names of the chapters, some of them are even named like the pipeline phases:
- The CI pipeline
- Automated acceptance testing
- Configuration management with Ansible
The rest of the chapters give the introduction, summary, or additional information complementary to the process.
There is also a second perspective to the content of this book. Each chapter describes one piece of the environment, which, in turn, is well prepared for the CD process. In other words, the book presents, step by step, technology by technology, how to build a complete system. To help you get the feeling of what we plan to build throughout the book, let's now have a look at how the system will evolve in each chapter.
Don't worry if you don't understand the concepts and terminology at this point. We will be learning everything from scratch in the corresponding chapters.
In Chapter 2, Introducing Docker, we start from the center of our system and build a working application packaged as a Docker image. The output of this chapter is presented in the following diagram:
A dockerized application (web service) is run as a container on a Docker Host and is reachable as it would run directly on the host machine. That is possible thanks to port forwarding (port publishing in Docker's terminology).
In Chapter 3, Configuring Jenkins, we prepare the Jenkins environment. Thanks to the support of multiple agent (slave) nodes, it is able to handle the heavy concurrent load. The result is presented in the following diagram:
The Jenkins master accepts a build request, but execution is started at one of the Jenkins Slave (agent) machines. Such an approach provides horizontal scaling of the Jenkins environment.
In Chapter 4, Continuous Integration Pipeline, we'll show how to create the first phase of the CD pipeline, the commit stage. The output of this chapter is the system presented in the following diagram:
The application is a simple web service written in Java with the Spring Boot framework. Gradle is used as a build tool and GitHub as the source code repository. Every commit to GitHub automatically triggers the Jenkins build, which uses Gradle to compile Java code, run unit tests, and perform additional checks (code coverage, static code analysis, and so on). Once the Jenkins build is complete, a notification is sent to the developers.
After this chapter, you will be able to create a complete CI pipeline.
In Chapter 5, Automated Acceptance Testing, we'll finally merge the two technologies from the book title, Docker and Jenkins. This results in the system presented in the following diagram:
The additional elements in the diagram are related to the automated acceptance testing stage:
- Docker Registry: After the CI phase, the application is packaged first into a JAR file and then as a Docker image. That image is then pushed to the Docker Registry, which acts as storage for dockerized applications.
- Docker Host: Before performing the acceptance test suite, the application has to be started. Jenkins triggers a Docker Host machine to pull the dockerized application from the Docker Registry and starts it.
- Cucumber: After the application is started on the Docker Host, Jenkins runs a suite of acceptance tests written in the Cucumber framework.
InChapter 6,Clustering with Kubernetes, we replace a single Docker host with a Kubernetes cluster and a single standalone application with two dependent containerized applications. The output is the environment presented in the following diagram:
Kubernetes provides an abstraction layer for a set of Docker hosts and allows a simple communication between dependent applications. We no longer have to think about which exact machine our applications are deployed on. All we care about is the number of their instances.
InChapter 7,Configuration Management with Ansible, we create multiple environments using Ansible. The output is presented in the following diagram:
Ansible takes care of the environments and enables the deployment of the same applications on multiple machines. As a result, we have the mirrored environment for testing and for production.
In the last two chapters, that is, Chapter 8, Continuous Delivery Pipeline, and Chapter 9, Advanced Continuous Delivery, we deploy the application to the staging environment, run the acceptance testing suite, and finally release the application to the production environment, usually in many instances. The final improvement is the automatic management of the database schemas using Flyway migrations integrated into the delivery process. The final environment created in this book is presented in the following diagram:
I hope you are already excited by what we plan to build throughout this book. We will approach it step by step, explaining every detail and all the possible options in order to help you understand the procedures and tools. After reading this book, you will be able to introduce or improve the CD process in your projects.
In this chapter, we introduced the CD process starting from the idea, and discussed the prerequisites, to end up with tools that are used in the rest of this book. The key takeaway from this chapter is as follows: the delivery process currently used in most companies has significant shortcomings and can be improved using modern automation tools. The CD approach provides a number of benefits, of which the most significant ones are fast delivery, fast feedback cycle, and low-risk releases. The CD pipeline consists of three stages: CI, automated acceptance testing, and configuration management. Introducing CD usually requires a change in the organization's culture and structure. The most important tools in the context of CD are Docker, Jenkins, and Ansible.
In the next chapter, we'll introduce Docker and show you how to build a dockerized application.
To verify the knowledge acquired from this chapter, please answer the following questions:
- What are the three phases of the traditional delivery process?
- What are the three main stages of the CD pipeline?
- Name at least three benefits of using CD.
- What are the types of tests that should be automated as part of the CD pipeline?
- Should we have more integration or unit tests? Explain why.
- What does the term DevOps mean?
- What are the software tools that will be used throughout this book? Name at least four.
To learn more about the concept of CD and its background, please refer to the following resources: