Why Every DevOps Engineer Should Learn Python in 2026

#!/usr/bin/env bash
# Check that services respond; fine while it stays small
set -u
for url in https://example.com https://example.org; do
  code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 5 "$url")
  if [ "$code" = "200" ]; then
    echo "OK   $url"
  else
    echo "FAIL $url ($code)"
  fi
done

# pip install requests
import sys
import time
import requests

URLS = ["https://example.com", "https://example.org"]

def check(url: str, retries: int = 3) -> bool:
    for attempt in range(1, retries + 1):
        try:
            r = requests.get(url, timeout=5)
            if r.status_code == 200:
                return True
        except requests.RequestException as err:
            print(f"  attempt {attempt} failed: {err}")
        time.sleep(2 ** attempt)   # backoff: 2s, 4s, 8s
    return False

failed = [u for u in URLS if not check(u)]
for u in URLS:
    print(("FAIL " if u in failed else "OK   ") + u)
sys.exit(1 if failed else 0)

# pip install boto3   Needs read-only S3 permissions
import boto3
from botocore.exceptions import ClientError

s3 = boto3.client("s3")
for b in s3.list_buckets()["Buckets"]:
    name = b["Name"]
    try:
        cfg = s3.get_public_access_block(Bucket=name)["PublicAccessBlockConfiguration"]
        blocked = all(cfg.values())
    except ClientError as err:
        if err.response["Error"]["Code"] == "NoSuchPublicAccessBlockConfiguration":
            blocked = False
        else:
            raise
    print(f"{'OK  ' if blocked else 'WARN'} {name}")

# Stops running instances tagged env=dev; dry run by default
import argparse
import boto3

parser = argparse.ArgumentParser()
parser.add_argument("--apply", action="store_true", help="actually stop instances")
args = parser.parse_args()

ec2 = boto3.client("ec2", region_name="ap-south-1")
ids = []
for page in ec2.get_paginator("describe_instances").paginate(
        Filters=[{"Name": "tag:env", "Values": ["dev"]},
                 {"Name": "instance-state-name", "Values": ["running"]}]):
    for r in page["Reservations"]:
        ids += [i["InstanceId"] for i in r["Instances"]]

print("would stop:" if not args.apply else "stopping:", ids)
if args.apply and ids:
    ec2.stop_instances(InstanceIds=ids)

# pip install requests
import os
import requests

def notify(text: str) -> bool:
    url = os.environ.get("CHAT_WEBHOOK_URL")
    if not url:
        print("no webhook configured; message:", text)
        return False
    try:
        r = requests.post(url, json={"text": text}, timeout=5)
        r.raise_for_status()
        return True
    except requests.RequestException as err:
        print("notification failed:", err)
        return False

if __name__ == "__main__":
    notify("Deploy to staging finished: version 1.4.2")

# test_notify.py   Run: pytest -q
from unittest.mock import patch, MagicMock
import notify as n   # the module from the previous tab saved as notify.py

def test_returns_false_without_webhook(monkeypatch):
    monkeypatch.delenv("CHAT_WEBHOOK_URL", raising=False)
    assert n.notify("hi") is False

def test_posts_json(monkeypatch):
    monkeypatch.setenv("CHAT_WEBHOOK_URL", "https://chat.example/hook")
    fake = MagicMock()
    fake.raise_for_status.return_value = None
    with patch("notify.requests.post", return_value=fake) as post:
        assert n.notify("deployed") is True
        post.assert_called_once()
        assert post.call_args.kwargs["json"] == {"text": "deployed"}

Week 1  Python basics: types, functions, dicts, lists, files
Week 2  subprocess, pathlib, argparse; exit codes
Week 3  JSON, YAML and requests; error handling and retries
Week 4  Cloud SDK (boto3): list, tag, report; dry-run patterns
Week 5  pytest and mocking; packaging a small CLI
Week 6  Project: an ops tool used in a CI pipeline

Project: ops-toolkit CLI

Commands:
  ops audit-buckets       report bucket public access settings
  ops untagged            list resources missing team/env tags
  ops stop-dev --apply    stop dev instances (dry run by default)
  ops notify "message"    post to a chat webhook

Includes: argparse CLI, logging, pytest tests with mocks,
GitHub Actions workflow running tests, README with examples

import argparse
import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")

def main() -> None:
    parser = argparse.ArgumentParser(prog="ops")
    sub = parser.add_subparsers(dest="command", required=True)
    sub.add_parser("untagged", help="list untagged resources")
    stop = sub.add_parser("stop-dev", help="stop dev instances")
    stop.add_argument("--apply", action="store_true")
    args = parser.parse_args()
    logging.info("running %s", args.command)

if __name__ == "__main__":
    main()