Role requirements for a DevOps practitioner

Welcome back, and I hope you had a chance to review the resources and post on Day 1 of #120DaysOfDevOps. In our first post, we briefly touched on the concept of DevOps, but now it's time to delve deeper. It's important to understand that creating an application involves two main parts: Development and Operations.

During the Development phase, software developers write and test the code for the application. This is where the functionality is developed, bugs are identified and fixed, and features are added or modified based on user feedback. Once the application code is in good shape, it is ready for the Operations phase.

In the Operations phase, the application is deployed and maintained on a server. This includes tasks such as configuring the server environment, setting up networks, monitoring performance, and troubleshooting issues that arise. By combining the Development and Operations phases into a single process, DevOps aims to create a more efficient and streamlined approach to application development.

DevOps serves as an interface between Development and Operations disciplines.

To fully grasp DevOps and the tasks typically performed by a DevOps engineer, we need to understand the tools, processes, and overview of how they come together. At the heart of everything is the application itself, which is the focus of DevOps.

Developers create applications using various technology stacks, programming languages, build tools, and code repositories. As a DevOps engineer, you won't be writing the application code, but you'll need to have a good understanding of the concepts, systems, tools, and processes that developers use.

At a high level, you'll need to know how the application is configured to talk to all its required services or data sources, as well as how it can be tested. Once the application is ready, it needs to be deployed somewhere, such as on a server. This server can run on-premises, in a public cloud, or elsewhere. As a DevOps engineer, you may be responsible for deploying and configuring these servers.

These servers run on an operating system, typically Linux. We'll cover foundational knowledge about Linux in a dedicated section later on. Additionally, the application may need to communicate with other services in the network or environment, so you'll need to have knowledge about networking and configuration as well. This might include tasks like DNS, DHCP, and load balancing, which we'll also cover in more detail in a dedicated section.

At this point, it's worth noting that you don't need to be a Network or Infrastructure specialist to work in DevOps. Rather, a foundational knowledge of how to get systems up and running and communicating with each other is sufficient. It's similar to having a foundational knowledge of a programming language without being a developer.

That said, if you do come into DevOps as a specialist in a particular area, such as networking or infrastructure, you have a strong foundation to build upon when adapting to other areas. The key is to have a willingness to learn and adapt, which are essential qualities for success in DevOps.

DevOps Application Management Lifecycle

As we progress through the coming weeks, you'll undoubtedly encounter these titles—Continuous Development, Testing, Deployment, and Monitoring—repeatedly. If you're aiming for a DevOps Engineer role, then getting used to repetition will be par for the course. However, continuously improving each time is another thing that keeps things interesting.

In this hour, we'll take a high-level view of the application lifecycle from start to finish, and then back around again like a continuous loop. This cycle involves several stages, including Continuous Development, Testing, Deployment, and Monitoring. Understanding how these stages fit together is essential to developing a successful application and building a strong foundation for DevOps practices.

Application Creation/Development

Let's consider a brand new application as an example. At the outset, there's nothing created, and as a developer, you'll need to discuss the requirements with your client or end user and come up with a plan for your application.

As a DevOps engineer, you won't typically be involved in creating this plan or coding the application. However, having a basic understanding of the code can help you make informed infrastructure decisions down the line.

Choosing the right IDE and programming language is important at this stage, but you won't need much more than that in terms of tooling.

It's worth noting that the application can be written in any language, but it should be maintained using a version control system like Git. We'll cover Git in detail later on, including best practices for collaborating on code with other developers.

When developing an application, it's likely that multiple developers will work on the codebase. In such cases, a code repository is essential for storing and collaborating on code changes. There are many options for code repositories, such as GitHub or GitLab, which can be hosted publicly or privately. We'll delve into code repositories and their use in greater detail as part of our Git section later on.

Testing

Once we have our requirements and our application is being developed, it's crucial to test the code in all available environments or specifically for the programming language chosen. This phase enables Quality Assurance (QA) to identify bugs and issues.

Containers are often used to simulate testing environments, which can help reduce the cost overheads associated with physical or cloud infrastructure.

Automated testing is becoming increasingly popular in this phase, particularly as part of Continuous Integration. Automating the testing process can significantly accelerate the testing phase compared to manual testing by dozens, hundreds, or even thousands of QA engineers. This allows these engineers to focus on other critical areas within the stack to ensure faster development and more functionality rather than merely detecting and addressing software bugs, which can be a bottleneck in traditional software releases that use a Waterfall methodology.

Integration

Integration is a crucial practice in the DevOps lifecycle, as it enables developers to commit changes to the source code more frequently—on a daily or weekly basis, for example.

With each commit, the application can automatically go through various testing phases, allowing for early detection of bugs and issues before proceeding to the next phase.

It's worth noting that many companies purchase off-the-shelf software from vendors and may not be directly involved in the first three phases. However, adopting the final phase of the DevOps lifecycle can still enable faster and more efficient deployments of your off-the-shelf software.

Having knowledge about these phases is essential because while you may purchase off-the-shelf software today, you may encounter situations where you need to develop custom solutions tomorrow or down the line, such as in a future job. Being familiar with the DevOps lifecycle, including integration, can help you better understand how to deploy and maintain applications effectively.

Deployment

Now that we have built and tested our application to meet the requirements of our end-users, it's time to deploy it into production for consumption.

In this stage, code is deployed to production servers. However, deployment can become complicated because different applications may require varying hardware or configurations. That's where Application Configuration Management and Infrastructure as Code become essential in the DevOps lifecycle. Containerization might be a suitable option for your application, but it might also be runnable on a virtual machine. Platforms such as Kubernetes are used to orchestrate containers and ensure that the desired state is available to end-users.

We'll delve deeper into these topics over the next few weeks, understanding what they are and when to use them, to gain a better foundational knowledge.

Monitoring

As we continuously add new features and functionality to our application and run tests to catch any gremlins, it's essential to ensure that the end-users are getting the expected experience. Monitoring plays a significant role in achieving this objective.

Continuous monitoring of application performance enables developers to make informed decisions about future releases, enhancing the user experience. This phase also captures feedback from end-users, which can be used to improve and update the application continuously.

Reliability is another critical factor to consider; ensuring that the application remains available when required is paramount. Other aspects such as observability, security, and data management should also be continuously monitored, feeding back into the development process for better enhancement and continuous release of the application.

Additionally, it's crucial to involve the FinOps teams in this continuous process. Since apps and data are running and stored somewhere, it's essential to monitor them continuously to ensure that any changes in resources do not cause significant financial pain on your Cloud Bills.

It's worth noting that while there are many DevOps Engineer positions in the market, this title shouldn't be the primary goal for anyone. Rather, the DevOps culture and processes should be adopted across various positions, such as Cloud-Native engineer/architect, virtualisation admin, cloud architect/engineer, and infrastructure admin. The DevOps process applies to multiple positions and scopes, highlighted by the term "DevOps Engineer.