30 DevOps Challenges for Junior, Mid and Senior Engineers

Create a Dockerfile for a simple Node.js or Python web application.

FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD [ "node", "server.js" ]

Write a Jenkinsfile to check out code from a Git repository and run a simple command.

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'npm install'
            }
        }
    }
}

Write a Bash script to back up a directory to a .tar.gz file.

#!/bin/bash
tar -czvf backup.tar.gz /path/to/directory

Write an Ansible playbook to install a package on a remote server.

- hosts: webservers
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present

Initialize a Git repository, create a new branch, make a commit, and merge it back to the main branch.

git init
git checkout -b new-feature
# ... make changes ...
git add .
git commit -m "Add new feature"
git checkout main
git merge new-feature

Write a Terraform configuration to create a new AWS S3 bucket.

resource "aws_s3_bucket" "b" {
  bucket = "my-tf-test-bucket"
  acl    = "private"
}

Write a simple Prometheus configuration to scrape metrics from a running service.

scrape_configs:
  - job_name: 'my-app'
    static_configs:
      - targets: ['localhost:3000']

Write a Docker Compose file to run a web application and a database.

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
  db:
    image: "postgres"

Use the AWS CLI to create a new S3 bucket.

aws s3 mb s3://my-bucket

Write a shell script to check if a service is running.

#!/bin/bash
if systemctl is-active --quiet nginx; then
    echo "nginx is running"
else
    echo "nginx is not running"
fi

Write a Dockerfile that uses a multi-stage build to create a smaller final image.

# Build stage
FROM node:14 as builder
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Final stage
FROM nginx
COPY --from=builder /usr/src/app/build /usr/share/nginx/html

Write a Jenkinsfile that includes a testing stage before deploying the application.

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
            }
        }
    }
}

Create an Ansible role to install and configure a web server with a custom configuration.

# In roles/webserver/tasks/main.yml
- name: Install nginx
  apt:
    name: nginx
    state: present
- name: Copy nginx config
  copy:
    src: nginx.conf
    dest: /etc/nginx/nginx.conf

Create a Terraform module to manage a reusable piece of infrastructure, like a VPC.

# In modules/vpc/main.tf
resource "aws_vpc" "main" {
  cidr_block = var.cidr_block
}

# In main.tf
module "vpc" {
  source = "./modules/vpc"
  cidr_block = "10.0.0.0/16"
}

Write a Kubernetes manifest to deploy a simple application.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:1.0.0
        ports:
        - containerPort: 3000

Create a Grafana dashboard to visualize metrics from Prometheus.

# This is a visual task that would be done in the Grafana UI.

Write a Kubernetes manifest that uses a canary deployment strategy.

# This would involve creating two deployments, one for the stable version and one for the canary version, and a service that routes traffic to both.

Write a script to automate backups of an AWS EC2 instance.

# This would involve using the AWS CLI to create a snapshot of the EC2 instance's EBS volume.

Use Docker to run a private Docker registry.

docker run -d -p 5000:5000 --name registry registry:2

Write a Python script using the Boto3 library to list all S3 buckets.

import boto3

s3 = boto3.client('s3')
response = s3.list_buckets()

for bucket in response['Buckets']:
    print(f'  {bucket["Name"]}')

Design a cloud architecture that can handle a large amount of traffic and is resilient to failure.

# This would involve using a load balancer, auto-scaling groups, and a multi-AZ database.

Set up a GitOps workflow to automatically deploy changes to a Kubernetes cluster when they are pushed to a Git repository.

# This would involve installing Argo CD on a Kubernetes cluster and configuring it to watch a Git repository.

Write a custom Terraform provider to manage a resource that is not supported by any of the official providers.

# This is a complex task that would require a lot of code.
# A full implementation would be too long for this format.

Set up a service mesh to manage traffic between microservices in a Kubernetes cluster.

# This would involve installing Istio on a Kubernetes cluster and configuring it to manage traffic between services.

Use a tool like Chaos Monkey to randomly terminate instances in a production environment to test for resiliency.

# This would involve deploying Chaos Monkey to a production environment and configuring it to randomly terminate instances.

Design and implement a centralized logging system using the ELK stack (Elasticsearch, Logstash, and Kibana).

# This would involve setting up an ELK stack and configuring applications to send logs to it.

Use a tool like Chef InSpec to automate security compliance and auditing.

# This would involve writing InSpec profiles to check for compliance with security policies and running them against servers.

Create a Jenkins shared library to share common pipeline code across multiple projects.

# This would involve creating a Git repository with the shared library code and configuring Jenkins to use it.

Use Terraform to manage infrastructure across multiple cloud providers.

# This would involve using the Terraform providers for each cloud provider to manage infrastructure.

Write a script to automatically shut down idle resources to save money.

# This would involve using the AWS CLI or Boto3 to identify idle resources and shut them down.