When an application does not work, least of all you want to hear the phrase “the problem is at your side” from the colleagues. In the end it is the users who suffer, and it’s not important to them which part of the team is responsible for the crash. The DevOps culture appeared in order to bring together development and support and unite them in their shared responsibility for the final product.
What practices are part of DevOps and why? What do DevOps-engineers do and what should they be able to do? These and other questions are answered by EPAM experts: Kirill Sergeev, Systems Engineer и DevOps Evangelist, и Igor Boika, Systems Engineering Team Leader and coordinator of one of the DevOps teams inside the company.
Why is DevOps necessary?
Previously developers and support (also called operations) were separate. Paradoxically, their goals and KPIs were different, though they had common cause. The goal of development was to implement the business requirements as soon as possible and add the changes to the working product. Operations were responsible for the stable performance of the application, and all changes threaten stability. DevOps appeared as the way to solve this obvious conflict of interest.
What is DevOps?
That is a good, but debatable question. There is no global final consensus. Here in ЕРАМ it is thought that DevOps unites technologies, processes and the culture of teamwork. This unity aims for constant delivery of valuables to the end users.
Kirill Sergeev: “The developers are writing code, QA-engineers are testing it, and administrators set it up in the enterprise environment. For a long time, these parts of the team were somewhat disconnected, and then there appeared an idea to unite them within a common process. This was how DevOps practices came about”.
There came the day when the developers and the systems engineers became interested in each other’s work. The barrier between production and support gradually disappeared. This is how DevOps appeared with its technologies, processes and the culture of teamwork.
What is the essence of the DevOps culture?
It states that the responsibility for the result lies with every team member. The most interesting and the most difficult part of the DevOps philosophy is to understand that any single person is responsible not only for a narrow part of the work, but for the work of the whole product. The problem is not at someone else’s side, it’s shared, and every team member helps solving it.
The main goal of the DevOps culture is problem-solving, not just using DevOps practices. Moreover, these practices are introduced not at someone’s side, but cover the whole product. The project does not need the DevOps engineer per se—it needs a solution to a problem, and the role of the DevOps engineer may be shared by several team members with similar professional skills.
What DevOps practices are there?
DevOps covers all steps within the software lifecycle.
Igor Boika: “The ideal case is when we begin using the DevOps practices at the very start of the project. Together with the architects we plan the architectural landscape of the app, its location and scalability, choose its platform. Microservices are in fashion nowadays, and we choose the orchestration system for that: it is necessary to manage each element of the application separately and upgrade it independently from other elements. Another practice is Infrastructure as Code. This is an approach where the infrastructure of the project is created and managed with the help of code, not through direct interaction with servers.
The next stage is the development stage. One of the biggest practices here is CI/CD: it is necessary to help the developers to integrate their changes into the product quickly, in smaller packages, more often, and with less stress. CI/CD covers code review, code uploads to the codebase, and the deployment of the app into QA and production environments.
At the CI/CD stages the code passes quality gates. The code from the developer’s workstation must comply with a set of quality criteria, and the quality gates help here. After that the unit testing and UI testing appear. We can choose the most suitable deployment type for a fast, effortless and focused product deployment.
DevOps practices are possible during the support stage for the finished product. They can be used for monitoring, feedback, security, integration of changes. DevOps seeks constant improvement for all these tasks. We bring to a minimum and automate repeated operations. There you can also find migrations, app extensions, and maintenance.”
Why are DevOps practices useful?
If we had to write a textbook about modern DevOps practices, there would have been three items on the first page: automation, release acceleration, and instant user feedback.
Kirill Sergeev: “The first thing is automation. All team interactions can be automated: write code—review it—deploy it—get feedback—go back to start. All of that happens automatically.
The second thing is the acceleration of release and even the simplification of the development process. It is always important for the customer that the product enters the market as soon as possible and starts bringing value before the competitors unleash their products. Delivery process can be constantly improved: reduce the time, add new criteria, improve monitoring.
The third thing is instant user feedback. Whenever the users have some concerns, we can immediately introduce corrections and upgrade the application.”
How do the concepts “system engineer”, “build engineer” and “DevOps engineer” correlate?
These notions intersect but belong to slightly different areas.
A systems engineer at EPAM is a position. It can have different levels: from a junior to chief specialist.
A build engineer is rather a role that someone can have on a project. Now this is the name for those responsible for CI/CD.
A DevOps engineer is a specialist who implements DevOps practices on a project.
To sum up all this, it turns out like this: a person in the position of a system engineer who plays the role of a build engineer on the project and is engaged in the implementation of DevOps practices there.
What exactly does a DevOps engineer do?
DevOps engineers put together all the parts that make up a project. They know the work of developers, testers, and system administrators and help simplify that work. They understand the needs and requirements of the business and its role in the development process — and build the process taking into account the interests of the customer.
We have told a lot about automation, and this is the first thing that DevOps engineers do. This is a very large matter that, besides other things, includes environment preparation.
Kirill Sergeyev: “Before making updates to the product, these updates need to be tested on a third-party environment. It is being prepared by DevOps engineers. They also do all the work for introducing the DevOps culture on the project: they add DevOps practices to all layers of their projects. These three principles: automation, simplification, acceleration — are what they use everywhere where they can reach.”
What should a DevOps engineer know?
Essentially, a DevOps engineer should have knowledge pertaining to different areas, such as programming, administration of operating systems, and work with databases and build and configuration systems. This is added by the ability to work with cloud infrastructure and orchestration and monitoring systems.
1. Programming languages
DevOps engineers know several main languages for automation and can, for example, tell a developer: “How about you integrating code not manually, but with the help of our script that automates everything? This script will have a config file easily readable it both for you and us — and we can change it at any time. We will also see who, when, and why makes changes to it.”
A DevOps engineer can learn one or several of these languages: Python, Groovy, Bash, PowerShell, Ruby, and Go. Knowing them deeply is not required — it is enough to know just the basics of syntax, the principles of object-oriented programming, and be able to make simple scripts for automation.
2. Operating systems
DevOps engineers must understand on what server the product will be installed, in what environment it run, and with which services it will interact. One can choose to be specialized either in the Windows or Linux family.
3. Version control systems
A DevOps engineer cannot do without knowledge of version control systems. Git is one of the most popular such systems at the time.
4. Cloud providers
Cloud providers include AWS, Google, and Azure, especially talking about the Windows field.
Kirill Sergeyev: “Cloud services provide us with virtual servers that fit the CI/CD use perfectly.
Installing ten physical servers requires about a hundred manual operations. Each server must be manually started, then the desired operating system must be installed and configured, then our software must be installed on these ten servers, and then you need to recheck everything ten times. Cloud services replace this procedure with ten lines of code, and good DevOps engineers should know how to operate them. This is how they save time, effort, and money — both for the customer and for the company.”
5. Orchestration systems: Docker and Kubernetes
Kirill Sergeyev: “Virtual servers have containers inside. We can install our application to each of those containers. When there are many containers, you need to manage them: to turn on some containers, to turn off others, or to do backup to some location. These becomes a rather complicated thing, for which you need an orchestration system.
Previously, each application was deployed on a separate server, and any change in the server’s work could affect the health of the application. Thanks to containers, applications become isolated and run separately — each on its own virtual machine. If a failure occurs, there is no need to waste time to find out the reason. It’s easier to destroy the old container and add a new one.”
6. Configuration systems: Chef, Ansible, Puppet
When you need to maintain a whole farm of servers, you have to do many repeated operations. This is long and difficult, while manual work increases the chance of error. This is where configuration systems come to rescue. They help create scripts that are highly readable to developers, DevOps engineers, and system administrators. These scripts help do the same operations on servers automatically, which reduces the number of manual operations (and thus errors).
What is the career a DevOps engineer can build?
One can develop both horizontally and vertically.
Igor Boyko: “From the point of view of horizontal development, DevOps engineers now have widest prospects. Everything is constantly changing, and one can build up skills in a variety of fields: from version control systems to monitoring, from configuration management to databases, and so on.
It makes sense becoming a system architect if one takes interest in exploring how applications works at all stages of their lifecycle — from development to support.”
What are ways to become a DevOps engineer?
- Read the books Phoenix Project and DevOps Handbook. These are the true foundation of the DevOps philosophy, let alone the fact the former one is a fiction novel.
- Learn the technologies listed above: on your own or taking online courses.
- Join an open source project as a DevOps engineer.
- Practice and propose DevOps practices on own and company projects.
Are you interested in starting your career as a DevOps-engineer? Meet the requirements and join our free DevOps trainings.
Source: Klever IT industry magazine.