↓ Skip to main content

The ABCs of DevOps: A Map of the Key Skills and Practices

902 words·5 mins· loading · loading ·
Table of Contents
Mysteries of DevOps - This article is part of a series.
Part 3: This Article

DevOps covers a lot of ground, and the lists of “skills you need” online tend to read like a shopping list of tools. Tools change every few years. The areas underneath them don’t.

This post is a map of the ten areas that DevOps work draws on. For each one: what it actually is, the first thing worth learning, and a real failure from my own homelab, Project Aether, that shows why it matters. If you haven’t read them, the two earlier posts cover the SDLC and why DevOps exists.


The map
#

# Area What it is Start with
1 Linux The operating system almost every server runs Files, permissions, processes, services (systemd), logs
2 Networking How machines find and talk to each other IP addresses, DNS, ports, NAT, TLS
3 Scripting Small programs that automate repetitive work Bash, then Python
4 Version control A history of every change, and a way to work on changes together Git: commits, branches, pull requests
5 Continuous integration Every change is merged often and tested automatically One pipeline that runs tests on each push (GitHub Actions is a good first one)
6 Continuous delivery Every change that passes tests can be released safely Automated deploys to a test environment, then production
7 Infrastructure as code Servers and networks described in files, created by tools Terraform for infrastructure, Ansible for configuration
8 Containers and orchestration Packaging an app with everything it needs, and running many of them Docker first, Kubernetes once Docker feels boring
9 Monitoring and logging Knowing what your system is doing, and being told when it stops Metrics (Prometheus), dashboards (Grafana), central logs
10 Culture How the team shares ownership, learns from failure and improves Writing a blameless incident review

The order matters a little. Linux, networking and Git come up in every other area, so they repay the time first. Kubernetes is near the bottom on purpose: it’s much easier to learn once you understand what it’s automating.


Why each one matters: ten real failures
#

A list of definitions doesn’t show why any of this is worth learning. Failures do. Every one of these happened in my homelab in the last few months.

  1. Linux. My cluster couldn’t decrypt any of its secrets, because the key file was readable only by root and the decrypting process ran as a different user. The error message said nothing about permissions. Knowing how Linux file ownership works found it in minutes.
  2. Networking. Two of my three Kubernetes nodes sent their logs nowhere for days, because they asked a public DNS server first and got the wrong address for an internal name. Understanding resolver order was the whole fix.
  3. Scripting. My backup script printed “Backup Complete!” every night while its heartbeat never arrived. One unquoted & in a config file broke it, and || true after every command hid it.
  4. Version control. A cold rebuild would have failed, because two files it needed were in .gitignore and only existed on my laptop. If it isn’t in Git, it doesn’t exist.
  5. Continuous integration. My checks ran as local hooks before each commit, which git commit --no-verify skips. A check that can be skipped isn’t a gate. The fix was to run the same checks in CI on every push and pull request, where nobody can skip them.
  6. Continuous delivery. My GitOps tool’s own installation drifted from Git for three weeks, because nothing compared them. Automating delivery includes automating the check that delivery happened.
  7. Infrastructure as code. My backups were written to a “second disk” that was really a folder on the first disk. The code said one thing and the machine did another. IaC needs tests that check the real result.
  8. Containers and orchestration. My Kubernetes “sync waves” were meant to deploy things in order, but they didn’t wait for each step to be ready. Orchestration only orders what it can measure.
  9. Monitoring. A monitor that had been red since the day I created it wasn’t monitoring anything. I’d learned to ignore it.
  10. Culture. The serious failures above each have a written review, and none of them blames anyone, including me. Each one ends with a change that makes the same mistake harder to repeat.

The full stories are in the Project Aether series, particularly Green Is Not a Status.


How the areas fit together
#

It’s tempting to treat these as ten separate subjects. They’re really one loop:

  1. You write a change (scripting, version control).
  2. It’s tested automatically (continuous integration).
  3. It’s released automatically, onto infrastructure that’s also defined in code (continuous delivery, infrastructure as code, containers).
  4. You watch what it does in the real world (monitoring).
  5. When something goes wrong, you learn from it and change the process (culture).

Linux and networking sit underneath all five steps. The tools in each step will change. The loop won’t.


Where to start
#

If you’re new to all of this, don’t try to learn ten things at once. Pick one small project that you’ll actually run for months, not just build once, such as a personal website, a small app or a homelab. Then add one area at a time as you need it: put it in Git, write a script to deploy it, add a pipeline, add monitoring. Running something long enough for it to break teaches more than any tutorial.

The next post covers how to turn that into a way into a DevOps career.

Mysteries of DevOps - This article is part of a series.
Part 3: This Article

Related