Welcome to Practical DevOps!
The first chapter of this book will deal with the background of DevOps and setting the scene for how DevOps fits into the wider world of Agile systems development.
An important part of DevOps is being able to explain to your coworkers what DevOps is and what it isn't.
The faster you can get everyone aboard the DevOps train, the sooner you will be able to perform the actual technical implementation!
In this chapter, we will cover the following topics:
- Introducing DevOps
- How fast is fast?
- The Agile wheel of wheels
- The cargo cult Agile fallacy
- DevOps and ITIL
DevOps is, by definition, a field that spans several disciplines. It is a field that is very practical and hands-on, but, at the same time, you must understand both the technical background and the non-technical cultural aspects. This book covers both the practical and soft skills required for a best-of-breed DevOps implementation in your organization.
The word DevOpsÂ is a combination of the words developmentÂ and operation. This wordplay already serves to give us a hint of the basic nature of the idea behind DevOps. It is a practice where the collaboration between different disciplines of software development is encouraged.
The origin of the word DevOps and the early days of the DevOps movement can be tracked rather precisely. Patrick Debois is a software developer and consultant with experience in many fields within IT. He was frustrated with the divide between developers and operations personnel. He tried getting people interested in the problem at conferences, but there wasn't much interest initially.
In 2009, there was a well-received talk at the O'Reilly Velocity Conference: 10+ Deploys per Day: Dev and Ops Cooperation at Flickr. Patrick then decided to organize an event in Ghent, Belgium, called DevOpsDays. This time, there was much interest, and the conference was a success. The name DevOpsDays struck a chord, and the conference has become a recurring event. DevOpsDays was abbreviated to DevOps in conversations on Twitter and various internet forums.
The DevOps movement has its roots in Agile software development principles.Â The Agile Manifesto was written in 2001 by a number of individuals wanting to improve the then current status quo of system development and find new waysÂ of working in the software development industry. The following is an excerptÂ from the Agile Manifesto, the now classic text, which is available on the web at http://agilemanifesto.org/:
"Individuals and interactions over processes and tools Working software over comprehensive documentation Customer collaboration over contract negotiation Responding to change over following a plan That is, while there is value in the items on the right, we value the items on the left more."
This may be seen as a fairly obvious beneficial way to workâwhy do we even have to state this obvious fact? Well, if you have ever worked in any large organization, you will know that the opposite principle seems to be in operation instead. Walls between different parts of an organization tend to form easily, even in smaller organizations, where at first it would appear to be impossible for such walls to form.
DevOps, then, tends to emphasize that interactions between individuals are very important, and that technology may possibly assist in making these interactions happen and tear down the walls inside organizations. This may seem counter-intuitive, given that the first principle favors interaction among people over tools, but my opinion is that any tool can have several effects when used. If we use the tools properly, they can facilitate all of the desired properties of an Agile workplace.
A very simple example may be the choice of systems used to report bugs. Quite often, development teams and quality assurance teams use different systems to handle tasks and bugs. This creates unnecessary friction between the teams and further separates them when they should really be focusing on working together instead. The operations team may, in turn, use a third system to handle requests for deployment to the organization's servers.
An engineer with a DevOps mindset, on the other hand, will immediately recognize all three systems as being workflow systems with similar properties. It should be possible for everyone in the three different teams to use the same system, perhaps tweaked to generate different views for the different roles. A further benefit would be smaller maintenance costs, since three systems are replaced by one.
The turnaround for DevOps processes must be fast. We need to consider the time to market in the larger perspective, and simply stay focused on our tasks in the smaller perspective. This line of thought is also held by the CD movement.
As with many things Agile, many of the ideas in DevOps and CD are in fact different names of the same basic concepts. There really isn't any contention between the two concepts; they are two sides of the same coin.
DevOps engineers work on making enterprise processes faster, more efficient, and more reliable. Repetitive manual labor, which is error-prone, is removed whenever possible.
It's easy, however, to lose track of the goal when working with DevOps implementations. Doing nothing faster is of no use to anyone. Instead, weÂ must keep track of delivering increased business value.
For instance, increased communication between roles in the organization hasÂ clear value. Your product owners may be wondering how the developmentÂ process is going and are eager to have a look. In this situation, it is useful to be able to deliver incremental improvements of code to the test environments quickly and efficiently. In the test environments, the involved stake holders, such as product owners and, of course, the quality assurance teams, can follow the progress of the development process.
Another way to look at it is this: if you ever feel yourself losing focus because of needless waiting, something is wrong with your processes or your tooling. If you find yourself watching videos of robots shooting balloons during compile time,Â your compile times are too long!
The same is true for teams idling while waiting for deploys and so on. This idling is, of course, even more expensive than that of a single individual.
There are several different cycles in Agile development, from the Portfolio level through to the Scrum and Kanban cycles and down to the Continuous Integration (CI) cycle. The emphasis on which cadence work happens in is a bit different depending on which Agile framework you are working with. Kanban emphasizes the 24-hour cycle, which is popular in operations teams. Scrum cycles can be two to four weeks and are often used by development teams using the Scrum Agile process. Longer cycles are also common and are called Program Increments (PI), which span several Scrum Sprint cycles, in theÂ Scaled Agile FrameworkÂ (SAFeÂ®):
The Agile wheel of wheels
DevOps must be able to support all these cycles. This is quite natural given the central theme of DevOps: cooperation between disciplines in an Agile organization.
The most obvious and measurably concrete benefits of DevOps occur in the shorter cycles, which in turn makes the longer cycles more efficient. Take care of the pennies, and the pounds will take care of themselves, as the old adage goes.
- Deployment systems, maintained by DevOps engineers, make the deliveries at the end of Scrum cycles faster and more efficient. These can take place with a periodicity of two to four weeks.
- In organizations where deployments are done mostly by hand, the time to deploy can be several days. Organizations that have these inefficient deployment processes will benefit greatly from a DevOps mindset.
- The Kanban cycle is 24 hours, and it's therefore obvious that the deployment cycle needs to be much faster than that if we are to succeed with Kanban.
- A well-designed DevOps CD pipeline can deploy code from being committed to the code repository to production in a matter of minutes, depending on the size of the change.
Richard Feynman was awarded the Nobel prize for his work in the field of quantum physics in 1965. He noticed a common behavior among scientists, in which they went though all the motions of science but missed some central, vital ingredient of the scientific process. He called this behavior cargo cult science, since it was reminiscent of the cargo cults in the Melanesian South Sea islands. These cargo cults were formed during the World War II when the islanders watched great planes land with useful cargo. After the war stopped, the cargo also stopped coming. The islanders started simulating landing strips, doing everything just as they had observed the American military do, in order for the planes to land.
We are not working in an Agile or DevOps-oriented manner simply because we have a free morning where we drink coffee and chat about the weather. We don't have a DevOps pipeline just because we have a Puppet implementation that only the operations team knows anything about.
It is very important that we keep track of our goals and continuously question whether we are doing the right thing and are still on the right track. This is central to all Agile thinking. It is, however, something that is manifestly very hard to do in practice. It is easy to wind up as followers of the cargo cults.
When constructing deployment pipelines, for example, keep in mind why we are building them in the first place. The goal is to allow people to interact with new systems faster and with less work. This, in turn, helps people with different roles interact with one another more efficiently and with less turnaround.
If, on the other hand, we build a pipeline that only helps only one group of peopleÂ achieve their goals, for instance, the operations personnel, we have failed toÂ achieve our basic goal.
While this is not an exact science, it pays to bear in mind that Agile cycles, such as the Sprint cycle in the Scrum Agile method, normally have a method to deal with this situation. In Scrum, this is called the Sprint Retrospective, where the team gets together and discusses what went well and what could have gone better during the sprint. Spend some time here to make sure you are doing the right thing in your daily work.
A common problem here is that the output from the Sprint Retrospective isn't really acted upon. This, in turn, may be caused by the unfortunate fact that the identified problems were really caused by some other part of the organization that you don't communicate well with. Therefore, these problems come up again and again in the retrospectives and are never remedied.
If you recognize that your team is in this situation, you will benefit from the DevOps approach since it emphasizes cooperation between roles in the organization.
To summarize, try to use the mechanisms provided in the Agile methods in your methods themselves. If you are using Scrum, use the Sprint Retrospective mechanism to capture potential improvements. This being said, don't take the methods as gospel. Find out what works for you.
DevOps fits well together with many frameworks for Agile or Lean enterprises. SAFeÂ® specifically mentions DevOps. There is nearly never any disagreement between proponents of different Agile practices and DevOps since DevOps originated in the Agile environment. The story is a bit different with theÂ Information Technology Infrastructure Library (ITIL), though.
ITIL, which was formerly known as the Information Technology Infrastructure Library, is a practice used by many large and mature organizations.
ITIL is a large framework that formalizes many aspects of the software life cycle. While DevOps and CD hold the view that the changesets we deliver to production should be small and happen often, at first glance, ITIL would appear to hold the opposite view. It should be noted that this isn't really true. Legacy systems are quite often monolithic, and in these cases, you need a process such as ITIL to manage the complex changes often associated with large monolithic systems.
If you are working in a large organization, the likelihood that you are working with such large monolithic legacy systems is very high.
In any case, many of the practices described in ITIL translate directly into corresponding DevOps practices. ITIL prescribes a configuration management system and a configuration management database. These types of systems are also integral to DevOps, and several of them will be described in this book.
This chapter presented a brief overview of the background of the DevOps movement. We discussed the history of DevOps and its roots in developmentÂ and operations, as well as in the Agile movement. We also took a look at how ITILÂ and DevOps might coexist in larger organizations. The cargo cult anti-patternÂ was explored, and we discussed how to avoid it. You should now be able to answer the question of where DevOps fits into a larger Agile context and the different cyclesÂ of Agile development.
We will gradually move towards more technical and hands-on subjects. The next chapter will present an overview of what the technical systems we tend to focus on in DevOps look like.