DevOps Course Curriculum: Beginner to Advanced Levels

#!/usr/bin/env bash
# server-check.sh - a typical beginner-level script
set -euo pipefail

echo "Host: $(hostname)"
echo "Uptime: $(uptime -p)"

# Disk usage of the root partition (percentage)
usage=$(df / --output=pcent | tail -1 | tr -dc '0-9')
if [ "$usage" -gt 80 ]; then
  echo "WARNING: root disk is ${usage}% full"
else
  echo "Disk OK: ${usage}% used"
fi

# Is nginx running?
if systemctl is-active --quiet nginx; then
  echo "nginx: running"
else
  echo "nginx: NOT running"
fi

# Which ports are listening?
ss -tlnp | head -10

# Daily Git workflow every DevOps beginner should practise
git clone https://github.com/<you>/devops-practice.git
cd devops-practice

git switch -c feature/server-check
cp ~/server-check.sh scripts/
git add scripts/server-check.sh
git commit -m "Add server health check script"
git push -u origin feature/server-check
# Open a pull request on GitHub, get it reviewed, merge

# Undo a bad commit that is already pushed
git revert <commit-sha>

# See what changed and who changed it
git log --oneline --graph -10

# .github/workflows/ci.yml
name: ci
on:
  push:
    branches: [main]
  pull_request:

jobs:
  build-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install -r requirements.txt
      - run: pytest -q
      - name: Build image
        run: docker build -t myapp:${{ github.sha }} .

# Dockerfile for a small Python web app
FROM python:3.12-slim

WORKDIR /app

# Install dependencies first so this layer is cached
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Do not run as root inside the container
RUN useradd --create-home appuser
USER appuser

EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: registry.example.com/myapp:1.4.0
          ports:
            - containerPort: 8000
          resources:
            requests: { cpu: 100m, memory: 128Mi }
            limits: { cpu: 500m, memory: 256Mi }
          readinessProbe:
            httpGet: { path: /health, port: 8000 }
            periodSeconds: 5

# main.tf - a small VPC described as code
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "ap-south-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = { Name = "devops-lab" }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
}

# terraform init && terraform plan && terraform apply
# terraform destroy when the lab is finished

DEVOPS STUDY PLAN (fill in your own dates)

LEVEL 1 - FOUNDATION          Start: ____  End: ____
[ ] Linux file system, users, permissions
[ ] Processes, services, logs (systemctl, journalctl)
[ ] Networking: IP, ports, DNS, curl, ssh
[ ] Bash scripting with error handling
[ ] Git branches, pull requests, conflicts

LEVEL 2 - PIPELINES AND CONTAINERS   Start: ____  End: ____
[ ] Jenkins or GitHub Actions pipeline
[ ] Dockerfile, images, registry, Compose
[ ] Kubernetes: Pod, Deployment, Service

LEVEL 3 - PLATFORM             Start: ____  End: ____
[ ] Helm, Ingress, probes, limits, rollbacks
[ ] AWS: VPC, EC2, IAM, S3, EKS basics
[ ] Terraform modules and remote state
[ ] Prometheus and Grafana, alerting
[ ] Image scanning and secrets in CI

Weekly rule: 1 new topic + 1 hands-on task + 1 written note

PROJECT LADDER - one project per level

P1 Foundation
   Script that installs nginx, deploys a static site,
   checks health and logs results. Stored in GitHub.

P2 Pipelines
   Small Python or Node app with tests.
   CI runs tests on every pull request,
   builds a Docker image, pushes to a registry.

P3 Containers
   Same app plus a database on Docker Compose,
   then deployed to a local kind cluster.

P4 Platform (capstone)
   Terraform creates network and cluster on AWS.
   Pipeline deploys with Helm.
   Grafana dashboard shows requests and errors.
   README explains architecture with a diagram.

Each README: problem, tools, how to run, what you learned.

SYLLABUS CHECKLIST - ask before you enrol

Coverage
[ ] Linux and networking taught properly, not skipped
[ ] Git with branches and pull requests
[ ] At least one CI tool built hands-on
[ ] Docker and Kubernetes, beyond 'hello world'
[ ] Terraform or another IaC tool
[ ] Monitoring and logging
[ ] Security basics in the pipeline

Practice
[ ] Lab access for cloud and clusters
[ ] Projects reviewed by a trainer
[ ] Capstone that links all levels

Support
[ ] Recordings or batch repeat if you miss classes
[ ] Resume, portfolio review and mock interviews
[ ] Current syllabus and fees shared in writing