How Commerce Graduates Can Enter DevOps in 2026

#!/bin/bash
# health_check.sh — the first DevOps script most engineers write.
# Runs on a Linux server, checks the essentials, and prints a summary.

set -euo pipefail

LOG_FILE="/var/log/health_check.log"

echo "=== Server Health Check $(date) ===" | tee -a "$LOG_FILE"

# 1. Disk usage
echo "Disk usage:" | tee -a "$LOG_FILE"
df -h / | tee -a "$LOG_FILE"

# 2. Memory usage
echo "Memory usage:" | tee -a "$LOG_FILE"
free -m | tee -a "$LOG_FILE"

# 3. Top CPU processes
echo "Top CPU processes:" | tee -a "$LOG_FILE"
ps -eo pid,comm,%cpu --sort=-%cpu | head -5 | tee -a "$LOG_FILE"

# 4. Alert if disk usage > 80%
DISK_USED=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$DISK_USED" -gt 80 ]; then
  echo "WARNING: Disk usage is at ${DISK_USED}%" | tee -a "$LOG_FILE"
fi

# What this teaches:
# - How to write idempotent shell scripts (safe to run any time).
# - How to reason about system state (disk, memory, processes).
# - How to log outcomes for later inspection.
#
# Why this matters for a career switch:
# - Every DevOps engineer has written scripts like this.
# - It shows you can reason about servers, not just apps.
# - It is small enough to walk through in an interview.

# .github/workflows/build-deploy.yml — a real CI pipeline
# The kind of automation every DevOps role expects.

name: Build and Deploy

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"
      - run: pip install -r requirements.txt
      - run: pytest

  build-and-push:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - name: Login to DockerHub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Build and push image
        run: |
          docker build -t ${{ secrets.DOCKER_USERNAME }}/myapp:${{ github.sha }} .
          docker push ${{ secrets.DOCKER_USERNAME }}/myapp:${{ github.sha }}

  deploy:
    needs: build-and-push
    runs-on: ubuntu-latest
    steps:
      - name: Deploy over SSH
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SERVER_KEY }}
          script: |
            docker pull ${{ secrets.DOCKER_USERNAME }}/myapp:${{ github.sha }}
            docker stop myapp || true
            docker rm myapp || true
            docker run -d --name myapp -p 80:8000 ${{ secrets.DOCKER_USERNAME }}/myapp:${{ github.sha }}

# What this teaches:
# - How CI pipelines separate stages (test → build → deploy).
# - How secrets are used to protect credentials.
# - How deployments can be triggered by code changes.
#
# Why this matters for a career switch:
# - CI/CD is the heart of DevOps.
# - This pipeline is small, real, and interview-ready.
# - It demonstrates that you can ship software, not just write scripts.

# main.tf — a real Terraform setup for a small AWS environment
# Infrastructure as Code is a core DevOps skill.

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

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "devops-demo-vpc"
  }
}

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

  tags = {
    Name = "devops-demo-public-subnet"
  }
}

resource "aws_security_group" "web" {
  name        = "devops-demo-web-sg"
  description = "Allow HTTP"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "web" {
  ami                    = "ami-0abcdef1234567890"
  instance_type          = "t3.micro"
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]

  tags = {
    Name = "devops-demo-web"
  }
}

output "instance_public_ip" {
  value = aws_instance.web.public_ip
}

# What this teaches:
# - How to describe cloud infrastructure as code.
# - How resources reference each other (VPC → subnet → security group → instance).
# - How outputs make automation easier.
#
# Why this matters:
# - IaC is the difference between a clicking sysadmin and a DevOps engineer.
# - Interviewers often ask "how would you provision this reproducibly?"