DevOps as a separate discipline (and as a term – Development + Operations = DevOps) appeared in 2009 after the first DevOps Days conference, organized by Belgian developer Patrick Debois (although, I must say that some sources believe that DevOps appeared in 2008, and after the conference became widespread). The conference brought together system administrators, developers, managers, and system programmers from all over the world.
The idea of DevOps, proposing a new way of interaction between development, testing, and implementation teams, was so much to their liking that with them it scattered and began to be broadcast around the planet.
Interestingly, DevOps did not appear at the suggestion of a large vendor, but, was born out of the needs of practitioners – system administrators, developers, project managers. Thanks to this, DevOps has gradually become a fairly massive movement in the IT field.
DevOps ideologists spent a lot of time and effort describing and discussing it. But they faced the shortcomings of conventional IT tools with which they had to work. This is how a generation of new tools appeared that allowed to formalize the so-called best practices, such as puppet, chef, vagrant, Jenkins, etc.
However, DevOps did not become popular overnight. In 2011, Gartner analyst Cameron Haight mentioned it as a promising and, possibly, interesting direction for big business in his presentation. Shortly thereafter, there is a surge of interest in DevOps from corporations and large vendors who are rushing to adopt DevOps best practices.
What are the 5 DevOps Principles?
Ok, we took a short excursion into history, and now let’s figure out what is so good about DevOps, in addition to the fact that it was created by practitioners, and therefore to solve the pressing practical problems that they faced.
DevOps removed the wall between development and implementation. As a result, this simplified and accelerated the process of their interaction, which means that it was beneficial for the business as well because the efficiency of the processes increased significantly.
In a DevOps culture, there is no way that developers do their part and they are not too interested in whether system administrators can run it in production. And system administrators, in their turn, “cover-up” the developers, who, in their opinion, handed them a product of little use to work.
In a DevOps culture, everyone is responsible for the result. This means that the emerging problem is a common one, and everyone should be maximally interested in its elimination.
So, the 5 basic principles of DevOps:
- Automation – Automate everything you can. Which is impossible, too. So that all processes for testing, building, and deploying the application, rolling out updates, collecting feedback are carried out automatically.
- Acceleration of release, including through simplification of the development process. This principle emphasizes the direct connection between the DevOps ideology and the needs of the business – the sooner the customer receives the final working product, the higher the efficiency and competitiveness of his business will be. Therefore, DevOps actively uses best practices that help, for example, improve monitoring processes or reduce the time spent on the processes of delivering a product to a user.
- Getting quick feedback – it was the DevOps methodology that made it possible to speed up this process, and most importantly, to promptly make adjustments to the product and make updates to the OS from users.
- Availability of standards. For DevOps, it is important to have templates and standards for configuring and using certain tools. Thanks to this, a complex process involving both development, testing, and operation does not turn into “chaos”, but, on the contrary, gets the opportunity to automate each stage.
- Continuous testing. The process of running continuous security tests allows you to fully control the process and quickly respond to emerging problems.
DevOps is often viewed in terms of some ideology overlap with the Agile development approach. But in our case, this approach is scaled not only for development but also for operation and testing. There are several principles that DevOps borrows from Agile. By the way, the automation principle described above also goes back to Agile.
5 principles of DevOps borrowed from Agile (CALMS)
- Culture – since DevOps implies a certain culture of interaction between different departments – development, testing, operation;
- Leanness – this implies a respectful attitude to the processes and the time spent on them, which means the rejection of actions with low efficiency, the constant search for methods to improve productivity and speed up processes, prompt detection, and solution of problems.
- Measurements – Metrics and performance metrics are very important in DevOps.
- Exchange is a clause about the joint responsibility of several teams for the life of the product.
- Automation – we have already talked about the principle of “Automate everything” a little higher.
7 DevOps practices and tools for their implementation
Although the DevOps methodology was created to a greater extent by the developers, system administrators played an equally important role in its dissemination, since the proposed toolkit was aimed, among other things, at increasing the efficiency of their work. DevOps has significantly transformed their work and area of responsibility in general.
Before that, system administrators were faced with the task of supporting a large number of various applications, which means that they had to perform a large amount of work for each of them – it was necessary to configure databases and servers, balance the load, manage security, etc., etc. Of course, with the advent of DevOps, these tasks have not disappeared anywhere. But DevOps offered a toolkit that standardized the process of configuring, deploying, and launching applications.
Before the advent of the DevOps methodology, the process of development and subsequent deployment of software was a fairly strict sequence – in fact, development, testing, commissioning. The DevOps approach became a kind of buffer that allowed developers and operations specialists to work both in closer cooperation and to be less dependent on the problems and peculiarities of each other’s activities. And the emergence of DevOps tools as a kind of collaborative ecosystem completely erased the existing lines between development and operation.
Throughout the application lifecycle, DevOps applies specific techniques at different stages that either automate and accelerate a specific stage or allow you to create a holistic productive process, covering several stages at once.
Continuous Integration and Delivery (CI / CD)
With the help of continuous integration, developers can quickly add changes to the main code. It is automatically tested immediately, which improves the stability of the application.
With continuous delivery, new versions are automatically deployed to production regularly. by automating this operation, more frequent updates are possible.
That is, CI / CD allows you to automate everything from committing code to deploying it to production. This allows you to reduce time and effort for routine operations and speed up the process of deploying code with minimal risk.
Version control keeps track of all fixes and changes to the code, which helps to simplify the process of analyzing and recovering from errors. Version control systems allow the development team to collaboratively create code, ensuring that changes in files are consolidated, conflicts are resolved, and, if necessary, rolled back to earlier versions. Thus, the tasks of writing code are divided between the teams, all the code can be restored in case of problems, this significantly speeds up development.
Agile software development
In this technique, a collaboration of different teams is very important, getting quick feedback from users and adapting to short software release cycles. This allows you to take into account the wishes of customers and quickly make changes to applications.
Infrastructure as code
This methodology describes system resources as code, which helps you deploy development, test, and production environments quickly, predictably, and reliably. Reduces the risk of human error.
This technique allows you to manage the state of resources (servers, virtual machines, and databases) on the system. By using specific tools, the DevOps engineer can roll out changes in a controlled and systematic way, while minimizing the risks of configuration changes. And also track the current state of the system and any changes/deviations in the configuration from its desired state.
Using this technique in conjunction with IaC, it is possible to automate the configuration of any, most complex, system.
The technique involves monitoring in real-time the performance and health of the application. To do this, certain telemetry and metadata metrics are automatically collected, and alerts about deviations in the application are configured.
This information helps you solve emerging problems very quickly and helps you understand what can be improved in future development cycles.
Thus, the following processes are often in charge of a DevOps engineer (although there are several independent professions – automation engineer, release engineer, security engineer, etc.):
- Working with code in terms of its analysis and version control, as well as writing scripts (Code)
- Continuous Integration Process for New Code (Build)
- Continuous Testing Process with Online Feedback (Test)
- The application installation process (Operate)
- Release automation process, including in terms of change management (Release)
- Continuous deployment process, infrastructure as code (Deploy) management
- Continuous application monitoring process (Monitor)
Tools Used for DevOps
To solve these problems, DevOps uses a wide range of tools, for example:
- For planning and evaluation – JIRA.
- For version control – Git, Mercurial, GitHub / Bitbucket / GitLab hosting.
- Containerization tools – Docker, rkt, CRI-O, Swarm, Nomad by HashiCorp, Kubernetes.
- For building and testing the application – Jenkins, TeamCity, GitLab CI, Bamboo.
- For continuous deployment and management of infrastructure as code – Puppet, Chef, Ansible, Salt Stack.
- For cloud resource management – Terraform.
- For monitoring and alerting – Prometheus, Grafana, New Relic, Data Dog, Alert Manager, PagerDuty.
I must say that the list is constantly expanding and replenished with new tools, which is why DevOps Services is not a static discipline, but a constant path of self-education and improvement of both your knowledge and the work of applications entrusted to you.