This article is a follow-up to the talk given by Volodymyr Tsap, co-founder and CTO at SHALB, at Chernihiv.IT conference 2022


In Part 1, we outlined the knowledge and skills that will help you make a successful start in DevOps. Now let’s talk about the expertise that you need to build a career in the field.


Part 2. DevOps Hard Skills

Learn YAML

To a large extent, I’d say that programming in DevOps centers around working with files, particularly YAML or configuration ones. YAML is a perfect choice for configuration thanks to its broad language support and human-readable format: Ansible, K8s, and Docker all use it.


Although a lot of YAML files can look big and scary, they can actually be broken down and written quite easily if you know the basics. Start practicing reading and interpreting YAML in any visual editor with YAML support and syntax highlighting. You need to be able to read, interpret, and edit YAML files confidently since they are the file types you will deal with a lot in your DevOps career.



Virtualization is one of the fundamental things in IT. It is the technology behind cloud computing and XaaS, or the everything-as-a-service computing model. So, a firm understanding of virtualization is vital, whichever role in DevOps you choose.


Clouds make things easier by putting a virtualization layer away and leaving it to a provider to manage. However, working in a regulated enterprise such as banks or healthcare companies will require excellent applied skills as these organizations need to manage virtualization using their own resources. Moreover, strict compliance policies prevent them from locating their data in a cloud and require them to create their own virtualization baseline, often using VMware products.


I’d recommend starting with basic concepts of virtualization: understanding virtual machines (VMs) and their types, a hypervisor and the functions it performs, etc. Then, practice what you have learned by installing a hypervisor on your computer, experimenting with creating VMs, and setting up a network connection. This will help you get a better idea of how virtualization works.



Once you have some basic knowledge of virtualization, you can consider learning clouds. To help you navigate this extensive domain, I have outlined basic concepts that all cloud platforms have in common. Although their inner structure may vary, these concepts are widely applicable and vital to understanding cloud environments.


  • Cloud accounts – what is a cloud account and how it is organized; cloud management console.


  • Identity and access management (IAM) – understanding IAM roles and permissions for users and services to reach your cloud resources; the rules upon which these permissions are granted or denied.


  • Computing services – virtual servers, such as EC2 instances, VM instances, or other node types to run applications on the cloud platform infrastructure; how to create, configure and manage your working nodes, and what we can do with them.


  • Storage – cloud storage platforms and the principles of their operation; object storage classes; how to work with object storage.


  • Load balancing – principles of traffic distribution in cloud computing; how load balancing works; types and algorithms of cloud load balancing.


  • Security – cloud security measures; the concept of security groups and how they work; strategies to secure your data in a cloud; firewalls and traffic management.


  • Billing – understanding how your cloud resources are billed is vital to remain within budget and preventing your company from going bankrupt when paying cloud bills.



When working with clouds, knowing how to describe your resources in code is essential. Terraform has become an absolute leader in the DevOps world for defining, launching, and managing infrastructure as code (IaC) across different cloud and virtualization platforms. It is open source, well-maintained, and integrates easily with various technologies. Whatever IaC tool you may be presently using, writing Terraform code is a skill you will definitely need – even if you think you won’t.


I would suggest starting with the book Terraform: Up and Running by Yevgeniy Brikman, CEO of Gruntwork. This book is a hands-on manual with detailed code examples that will help you quickly progress from Terraform basics to running a full stack.


For those who have been using Terraform for some time and have some practical questions, I recommend the book Terraform Best Practices by Anton Babenko. Apart from being a long-time developer, CTO, and tech lead, the author is one of the most prolific open-source contributors to various Terraform & AWS projects. The book contains indisputable best practices and recommendations for Terraform users on how to write quality code, including structuring, naming, styling, and other practical advice.


When working with Terraform, be sure to leverage the advantages of Terraform Registry. Here you can find a variety of pre-made integrations (providers), configuration packages (modules), and security rules (policies) for use with Terraform. The Registry includes solutions developed by HashiCorp, third-party vendors, and the Terraform community. Furthermore, it is a rich source of examples of how to write quality Terraform code.


For more in-depth study, consider Awesome Terraform – a comprehensive, regularly updated list of resources on HashiCorp’s Terraform.



Container technology’s emergence changed how we develop, ship, and run applications. It quickly became the mainstream thanks to its simplicity of use and speed of delivery. To understand why containers are so important, I recommend the book Using Docker by Adrian Mouat – a hands-on guide to container technology and how to make it part of your development process.



Running containers in large numbers requires orchestration, and here is where Kubernetes enters the scene. The golden standard of container orchestration, Kubernetes was initially developed and donated to The Cloud Native Computing Foundation (CNCF) by Google. So far, it is the crowning project of CNCF that shapes the whole ecosystem of cloud-native projects.


The first thing that I would recommend is to sign-up for the Certified Kubernetes Administrator (CKA) program, a joint initiative of CNCF and the Linux Foundation, and take the certification exam. This will cost you some money, but you can easily get that back as your certification will prove your competency and open the doors to more job opportunities.


For training, you can take the free Introduction to Kubernetes course by The Linux Foundation. The course explains key concepts of Kubernetes and is a preliminary step to take The Fundamentals of Kubernetes – the course which is specifically designed to prepare you for the CKA exam.


For those wanting to dig in deeper and understand Kubernetes under the hood, I would refer to the tutorial Kubernetes The Hard Way. Written by Kelsey Hightower, one of the most well-known speakers on Kubernetes, this offers complete hands-on guidance on how to bootstrap a production-ready Kubernetes cluster.



If you consider running several clusters, I’d suggest Rancher as a cluster manager. First, it simplifies the complexities of Kubernetes abstractions by providing a robust, user-friendly UI. You can perform any actions concerning the provision and management of your environments from here.


Second, Rancher supports multi-cluster setups with ‘single-pane-of-glass’ management. Furthermore, advanced visualization options give you a clear view of the state of your environments and the infrastructure processes running within.


Third, it is open source and integrates with popular cloud-native tools from the Kubernetes ecosystem, such as Prometheus, Grafana, Helm, Fluentd.



When working with Kubernetes, it is essential to know what Helm is and how it can help you deploy your workloads to the cluster. Helm is an open-source package manager for Kubernetes. It uses charts – pre-made packages of all necessary versioned, pre-configured resources required to deploy a container to Kubernetes. Helm charts can be downloaded from the public registry and adapted if needed. Using Helm reduces the complexity of Kubernetes deployments as it offers reusable, easily customizable templates that can be used repeatedly.


Additional Resources

If you like watching YouTube videos, I recommend the DevOps Toolkit channel hosted by charismatic technology guru Viktor Farcic. You will find everything concerning DevOps, containers, Kubernetes, microservices, continuous integration, delivery and deployment (CI/CD), test-driven development (TDD), and much more.


On Twitter, subscribe to Learnk8s to get a comprehensive kit of educational materials for starting with Kubernetes.


Among my favorite resources is Kubernetes Podcast from Google, whose episodes I regularly listen to. It is a weekly news and interview show with insight from the Kubernetes community.


Test Your Knowledge

Once you have mastered the skills described above, try testing your knowledge by building a full-cycle environment to run a WordPress application in a Kubernetes cluster. Create a Git repository; define your Kubernetes infrastructure with Terraform code and deploy it to any preferred cloud; use Helm to deploy WordPress and a database to the cluster; make your applications scalable. That’s it – a simple task to prove whether you understand the principles of cloud infrastructure design and can apply the acquired knowledge.


CI/CD and GitOps

Anyone who had a tough time during deployments knows that delivering code to target environments can be a challenge. One way to eliminate after-hours work and focus your efforts where it actually matters is to employ deployment methods and strategies that can help operationalize your services:


  • Leverage the practices of Continuous Integration (CI) and Continuous Deployment (CD) to automate most deployment challenges away.


  • Learn to design CI/CD pipelines and the tooling needed for this.


  • Learn about GitOps and its advantages compared to a conventional approach to deployments.


  • Familiarize yourself with deployment strategies and choose the one that works best for your type of application and target environment.


Architecture and System Design

Let me clarify: this is a vast and complex field to study. Distributed systems are difficult to design, tricky to manage, and a headache to deploy. Yet this complexity should not detain you from exploring the topic.


First, as computing systems grow in complexity, distributed systems become increasingly widespread. Today applications no longer run in isolation: instead they rely on distributed systems to meet user expectations on availability and fault tolerance. Second, correct system design can significantly boost your workload efficiency. It is a powerful tool with pros outweighing its cons.


If you start learning system design, I presume you already have some knowledge in the field. To help you systemize it, I’d recommend the book Software Architecture: The Hard Parts by architecture veterans Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani. This deals with the commonly asked questions on distributed systems and describes inevitable trade-offs in system design.


One of the factors contributing to the rise of distributed systems is the shift from monolithic applications to microservices.


To obtain a holistic view of building, managing, and scaling microservices architectures, refer to the book Building Microservices by Sam Newman. With clear examples and practical advice, the author presents the latest solutions for modeling, integrating, testing, deploying, and monitoring autonomous services.



The list of resources gathered in this article reflects my opinion on the fundamentals of DevOps tools and practices. Under no circumstances should it be considered definitive or somehow limiting your possibilities for professional growth. Still, working through the mentioned books and tutorials will undoubtedly boost your career opportunities.


Lastly, let me give you one final piece of advice – to succeed in DevOps requires creativity in searching for solutions. Always be willing to learn and dig to the roots to understand the underlying implementation. These abilities will serve you well whichever DevOps career path you may choose.