WAIT — Slowing — last commit 4mo ago

• Last commit 4mo ago
• 80+ active contributors
• Distributed ownership (top contributor 7% of recent commits)
• Other licensed
• CI configured
• Tests present
• ⚠ Slowing — last commit 4mo ago
• ⚠ Non-standard license (Other) — review terms

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

A curated, community-driven repository of 2624+ DevOps and SRE interview questions and exercises spanning Linux, Kubernetes, AWS, Azure, GCP, Docker, Terraform, Ansible, Prometheus, Jenkins, and more. It serves as a living study guide and practice resource for engineers preparing for DevOps roles, structured around real-world technologies with solutions for hands-on exercises like shell scripting and infrastructure-as-code. Flat topic-driven structure: topics/ directory contains subdirectories for each domain (devops, kubernetes, git, aws, azure, cloud, etc.), each with its own README.md housing questions and answers. exercises/docker and exercises/shell contain practical challenges with solutions in solutions/ subdirectories. certificates/ tracks study paths for cloud and container certifications. coding/python/ houses standalone algorithm exercises. No monorepo complexity—purely content organization.

Junior and mid-level engineers preparing for DevOps/SRE interviews, career changers moving into infrastructure, and anyone studying for cloud certifications (AWS Solutions Architect, CKA, CKAD, AZ-900). Also useful for experienced engineers refreshing knowledge across the DevOps ecosystem.

Actively maintained and well-established: the repository has substantial depth (2624 exercises across 21+ topics with 21,890 lines of Python and 4,403 lines of shell), proper CI via .github/workflows/ci_workflow.yml, and translation support (Portuguese, Chinese variants). It's not a bleeding-edge project but a stable, community-curated knowledge base that has matured into a go-to reference.

Low risk as a study resource: it has no production dependencies beyond boto3==1.17.95 (for AWS examples), making maintenance burden minimal. The main risk is information staleness—certifications and cloud platforms evolve faster than a volunteer-maintained repo can track, and some exercises may reference outdated API versions. Single-maintainer risk (bregman-arie) is present but mitigated by the nature of the content (exercises don't need frequent breaking changes).

Community contributions via pull requests, as evidenced by CONTRIBUTING.md and translation efforts (Portuguese and Chinese READMEs). The CI workflow in .github/workflows/ci_workflow.yml runs on commits, likely validating markdown formatting and link integrity. Recent activity appears focused on expanding exercise coverage and maintaining translation parity.

Clone and explore locally: git clone https://github.com/bregman-arie/devops-exercises.git && cd devops-exercises. No installation needed—read markdown files directly or open README.md in your browser. To contribute: follow CONTRIBUTING.md, add exercises to relevant topics/*/README.md files or exercises/*/ subdirectories, and submit a pull request. For Python coding exercises, use Python 3.8+ (e.g., python3 coding/python/binary_search.py).

Daily commands: This is not a runnable application—it's a study repository. For exercises: (1) Shell exercises: bash exercises/shell/<exercise_name>.sh or read the markdown. (2) Python algorithms: python3 coding/python/<script_name>.py. (3) Docker examples: navigate to exercises/docker/docker-debugging.md and follow instructions. (4) Terraform/HCL: study .hcl files and apply with terraform init && terraform plan. (5) General: read markdown files in your favorite editor or GitHub's web interface.

• README.md — Entry point explaining the repository's purpose as a DevOps interview preparation resource with 2624 exercises across multiple topics; every contributor must understand the scope and audience.
• CONTRIBUTING.md — Defines contribution guidelines and standards for adding exercises; essential for maintaining consistency across the exercise collection.
• .github/workflows/ci_workflow.yml — CI/CD pipeline that validates contributions and ensures code quality; load-bearing for automated testing of submissions.
• topics/devops/README.md — Core topic index and entry point for the largest category of exercises; anchors the organizational structure of the repository.
• scripts/aws s3 event triggering/requirements.txt — Only external dependency file declaring boto3 for AWS exercises; critical for reproducibility of AWS-related scripts.
• prepare_for_interview.md — Interview preparation guide that contextualizes all exercises and provides study path recommendations for users.
• faq.md — Clarifies scope limitations and realistic expectations; prevents misuse and aligns contributor/user understanding.

• Topic Exercise Collections (Markdown, GitHub) — Organized markdown files containing questions, scenarios, and hints grouped by technology domain
  • Failure mode: Outdated content, incorrect answers, or missing explanations reduce learning effectiveness
• Certification Preparation Guides (Markdown, GitHub) — Curated study paths and exam prep materials for AWS, Kubernetes, and Azure certifications
  • Failure mode: Stale exam blueprints or missing topics reduce exam readiness
• Code Examples & Scripts (Python 3, boto3, Bash) — Executable Python and shell scripts demonstrating DevOps tooling and AWS API usage
  • Failure mode: Deprecated AWS API calls or broken scripts limit practical learning
• CI/CD Validation Pipeline (GitHub Actions) — GitHub Actions workflow ensuring contribution quality before merge
  • Failure mode: Misconfigured checks allow low-quality submissions; missing checks skip validation
• Documentation & Guides (Markdown, GitHub) — Main README, FAQ, CONTRIBUTING, and interview prep guides directing users
  • Failure mode: Unclear navigation or

Add a new DevOps exercise topic

1. Create a new topic directory under topics/ (e.g., topics/terraform/) (topics/terraform/README.md)
2. Structure exercises with clear questions, hints, and solutions sections following existing topic conventions (topics/devops/README.md)
3. Add link to new topic in main README.md under the topic index table (README.md)
4. Update prepare_for_interview.md to include new topic in the study roadmap (prepare_for_interview.md)
5. Submit pull request with changes; CI workflow will validate markdown formatting (.github/workflows/ci_workflow.yml)

Add exercise solutions and scripts

1. Create solution script in exercises/{category}/solutions/ directory (exercises/shell/solutions/directories_comparison.md)
2. Include explanation, code comments, and expected output in the solution file (exercises/docker/docker-debugging.md)
3. If adding Python code, follow structure of existing examples in coding/python/ (coding/python/binary_search.py)
4. For scripts requiring dependencies, update or create requirements.txt in the script directory (scripts/aws s3 event triggering/requirements.txt)

Add certification preparation content

1. Create certification markdown file in certificates/ directory (e.g., certificates/ckad.md) (certificates/cka.md)
2. Outline exam domains, key topics, resources, and practice questions (certificates/aws-certification-paths.md)
3. Link new certification guide from prepare_for_interview.md (prepare_for_interview.md)
4. Add reference images to images/ directory if creating architecture diagrams (images/design/cdn-no-downtime.png)

• Markdown + GitHub — Version-controlled, lightweight, easily searchable, supports collaborative editing through pull requests; ideal for asynchronous knowledge base with community contributions
• GitHub Actions CI — Native GitHub integration enables automated validation of markdown syntax and file structure without external service dependencies
• Python + boto3 — boto3 enables hands-on AWS exercise examples for users to test against real AWS APIs; Python's readability supports learning goals
• Shell Scripts — Directly executable; demonstrates practical DevOps automation for Linux/AWS scenarios without compilation or framework overhead

• Static markdown-based content instead of dynamic web application

  • Why: Simplifies hosting, version control, and community contribution without backend infrastructure
  • Consequence: Limited interactivity and no real-time exercise auto-grading; relies on community review for correctness

• No authentication or user progress tracking

  • Why: Reduces complexity and keeps focus on content rather than platform features; lower barrier to access
  • Consequence: Cannot provide personalized learning paths or save user progress; users manage their own study tracking

• Repository organized by topic/technology rather than difficulty level

  • Why: Mirrors how learners mentally organize DevOps domains; facilitates contributions grouped by expertise
  • Consequence: Users must manually navigate difficulty progression; recommend using prepare_for_interview.md as guide

• Multi-language translations done through duplicate markdown files (pt-BR, zh_CN)

  • Why: Simple to maintain and Git-friendly; no complex i18n framework overhead
  • Consequence: Translation updates require maintaining multiple file copies; higher manual synchronization burden

• Does not provide automated grading or real-time feedback on exercises
• Does not track user progress or learning analytics
• Does not host executable hands-on labs (only reference scripts)
• Does not provide video content or interactive tutorials
• Does not offer certification exam guarantees or official accreditation
• Does not simulate real interview environments or provide AI-driven question generation
• Not a replacement for official vendor training or certification courses

No production runtime—this is a static repository, so no env vars or services required for normal use. However: (1) Python examples assume Python 3.8+ installed locally; coding exercises may rely on libraries not listed (check imports in coding/python/*.py before running). (2) AWS examples require boto3==1.17.95 if you run them; version is dated (1.17.x is from early 2021), so AWS API signatures may have drifted. (3) Certificate paths (certificates/*.md) reference external certification exams; content may lag official exam updates. (4) Some exercise solutions may reference deprecated tools or syntax (e.g., older Kubernetes API versions). (5) Terraform/HCL examples have no clear version constraints—may break on newer Terraform versions. (6) No automated tests validate exercise correctness; solutions are community-vetted but can contain errors.

• Infrastructure as Code (IaC) — Terraform (HCL), Ansible, and CloudFormation examples throughout this repo assume understanding of declarative infrastructure definition; critical for DevOps interviews.
• Immutable Infrastructure — Docker and Kubernetes exercises in this repo rely on immutable container images; essential pattern for understanding modern deployment practices covered here.
• Container Orchestration — Kubernetes is a major topic (topics/kubernetes/README.md, CKA/CKAD cert prep) in this repo; orchestration patterns are fundamental to DevOps roles.
• CI/CD Pipelines — Jenkins, GitHub Actions, and pipeline patterns are central to the DevOps topic; understanding build-test-deploy automation is tested heavily in this repo's exercises.
• Observability (Metrics, Logs, Traces) — Prometheus and monitoring exercises in this repo reflect the SRE emphasis on observability; this is a core DevOps interview topic.
• Network Policies and DNS — Network topic in this repo covers DNS resolution, firewalls, and Kubernetes NetworkPolicies; essential for troubleshooting distributed systems.
• Storage Abstraction (PVC, PV, CSI) — Kubernetes storage exercises require understanding PersistentVolumes and StatefulSets; critical for stateful application deployment covered in Kubernetes questions.

• bregman-arie/python-exercises — Companion repository for Python interview prep; learners of this DevOps repo often need Python coding skills for infrastructure automation.
• bregman-arie/go-exercises — Linked sibling repo for Go language exercises; Go is increasingly used in DevOps tooling (Docker, Kubernetes, Terraform) and complements this repo's coverage.
• kelseyhightower/kubernetes-the-hard-way — Hands-on Kubernetes tutorial that complements the Kubernetes questions in topics/kubernetes/README.md with practical cluster setup.
• donnemartin/system-design-primer — System design and architecture patterns that align with DevOps and SRE concepts in this repo, especially for high-level interview prep.
• awslabs/aws-security-reference-architecture — Official AWS architecture guidance that reinforces secure infrastructure design covered in the AWS exercises and certificate paths.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add automated exercise validation script for exercises/ directory

The repo contains 2624+ exercises across multiple domains (docker, shell, etc.) but lacks automated validation. Many exercises in exercises/shell/ and exercises/docker/ likely have solutions that could be automatically tested. Adding a CI workflow to validate shell script solutions and docker exercises against test cases would ensure quality and catch regressions when contributors add new exercises.

• [ ] Create exercises/shell/tests/ directory with shell test framework (e.g., BATS or shunit2)
• [ ] Create exercises/docker/tests/ directory with docker validation scripts
• [ ] Add .github/workflows/validate-exercises.yml to run these tests on PR
• [ ] Document testing approach in CONTRIBUTING.md with examples for contributors adding new exercises
• [ ] Reference existing exercises/shell/solutions/ files as test cases

Add missing Python exercises and expand coding/python/ with test suite

The coding/python/ directory only contains 2 files (binary_search.py, merge_sort.py) despite DevOps heavily using Python. Contributors often need Python interview prep. Adding a test harness and common DevOps Python scenarios (file handling, API calls, data parsing) with unit tests would provide more value. The boto3==1.17.95 dependency suggests AWS SDK use but no AWS SDK exercises exist.

• [ ] Create coding/python/tests/ with pytest configuration for existing and new exercises
• [ ] Add coding/python/aws_sdk_basics.py with exercises for boto3 operations (S3, EC2, Lambda)
• [ ] Add coding/python/file_processing.py with realistic DevOps tasks (log parsing, config generation)
• [ ] Create coding/python/api_client.py for REST API interaction patterns
• [ ] Add .github/workflows/python-tests.yml to validate all Python exercises with pytest

Create infrastructure-as-code exercises validation for Terraform examples

The repo references Terraform heavily in the README topic list but has no dedicated exercises/terraform/ directory with actual code examples or validation. Given this is a DevOps repo, providing executable Terraform exercises with syntax validation and best-practices checks would be high-value. Contributors could add real-world scenarios (VPC setup, RDS deployment, etc.).

• [ ] Create exercises/terraform/ directory structure with subdirectories for different cloud providers (aws/, azure/, gcp/)
• [ ] Add terraform/ .tf example files for common patterns (e.g., exercises/terraform/aws/basic-ec2.tf, exercises/terraform/aws/solution-ec2.tf)
• [ ] Create .github/workflows/terraform-validate.yml using 'terraform validate' and 'terraform fmt --check' on all .tf files in exercises/
• [ ] Update CONTRIBUTING.md with Terraform exercise contribution guidelines
• [ ] Add exercises/terraform/README.md explaining how to use and test each scenario

• Add Python docstrings and type hints to coding/python/binary_search.py and coding/python/merge_sort.py to make them more educational and aid learning. Currently sparse on documentation.
• Create shell exercise solutions for common DevOps tasks (log parsing, system health checks, backup automation) in exercises/shell/solutions/ with corresponding exercise descriptions. Directory exists but has only 2 files (directories_comparison.md has a duplicate).
• Expand topics/terraform/README.md or topics/iac/README.md with practical Terraform interview questions and explanations, since 4,255 lines of HCL exist but Terraform Q&A coverage is unclear from the file listing.

This educational DevOps repository has moderate security concerns primarily centered on outdated dependencies and potential CI/CD configuration vulnerabilities. The main risk is the significantly outdated boto3 library (1.17.95 from 2021) which likely contains known vulnerabilities. Additionally, CI/CD configuration files and certificate-related paths require auditing to ensure no credentials are committed. The repository appears to be well-structured for educational purposes but lacks visible security scanning, dependency management best practices, and automated vulnerability detection. Recommendations include updating boto3 immediately, implementing pre-commit hooks for secret detection, adding SAST/DAST scanning to workflows, and establishing a security policy for educational content. No critical injection vulnerabilities, hardcoded secrets, or Docker misconfigurations are evident from the provided file structure, but deeper code inspection of Python scripts and workflow files would be needed for complete assessment.

• High · Outdated boto3 Dependency with Known Vulnerabilities — Dependencies/Package file (boto3==1.17.95). The codebase uses boto3==1.17.95, which is significantly outdated (released in June 2021). This version is over 2 years old and likely contains known security vulnerabilities. AWS SDK updates frequently include security patches for various attack vectors including credential handling, encryption, and API interactions. Fix: Update boto3 to the latest stable version (3.x or current 1.x). Run 'pip install --upgrade boto3' and test compatibility. Consider using a requirements.txt with flexible versioning (e.g., 'boto3>=1.26.0') and regularly audit dependencies using tools like 'pip-audit' or 'safety'.
• Medium · Potential Secrets in Configuration Files — .travis.yml, .github/workflows/ci_workflow.yml, certificates/ directory. The codebase includes .travis.yml, .github/workflows configuration files, and multiple certificate-related directories. CI/CD configuration files and certificate paths are common locations where secrets (API keys, credentials, AWS keys) can be accidentally committed. Fix: Audit .travis.yml and workflow files for any hardcoded credentials. Use GitHub Secrets for sensitive data in workflows. Implement pre-commit hooks using tools like 'git-secrets' or 'detect-secrets' to prevent credential commits. Never commit actual certificates or keys; use references or environment variables instead.
• Medium · Missing Security Configuration in CI/CD — .github/workflows/ci_workflow.yml. The CI/CD workflow file (.github/workflows/ci_workflow.yml) is referenced but not fully visible in the analysis. Workflows may lack security scanning, dependency checking, or proper secret handling, leading to vulnerable code being merged into main branches. Fix: Implement security scanning in CI/CD pipeline including: SAST (static analysis), dependency vulnerability scanning (Dependabot, pip-audit), container scanning if applicable, and code quality checks. Restrict secrets access using GitHub environment protection rules and OIDC tokens where possible.
• Low · Insufficient Dependency Pinning Strategy — Dependency management structure. Using exact version pinning (boto3==1.17.95) without regular updates creates technical debt. However, lack of version constraints file (.txt, .lock) means dependency management may be inconsistent across environments. Fix: Implement requirements.txt or Pipfile with both pin-able and flexible constraints. Use lock files (pip-compile, poetry.lock) for reproducible builds. Set up automated dependency update workflows (Dependabot) with security vulnerability scanning.
• Low · Public Repository with Educational Content Including Infrastructure Examples — exercises/ directory and throughout repository. This is a public repository containing DevOps and infrastructure exercises. While educational content is appropriate for public sharing, examples or exercises may inadvertently include patterns (AWS service configurations, Kubernetes manifests, Terraform code) that could be misused or lead to insecure practices if copied without modification. Fix: Ensure all educational examples follow security best practices. Add prominent warnings in README about not using examples directly in production without security review. Include comments highlighting security considerations for each example. Regularly audit exercise content for security anti-patterns.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/bregman-arie/devops-exercises shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live bregman-arie/devops-exercises repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/bregman-arie/devops-exercises.

What it runs against: a local clone of bregman-arie/devops-exercises — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in bregman-arie/devops-exercises | Confirms the artifact applies here, not a fork | | 2 | License is still Other | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 163 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of bregman-arie/devops-exercises. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/bregman-arie/devops-exercises.git
#   cd devops-exercises
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of bregman-arie/devops-exercises and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "bregman-arie/devops-exercises(\\.git)?\\b" \\
  && ok "origin remote is bregman-arie/devops-exercises" \\
  || miss "origin remote is not bregman-arie/devops-exercises (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Other)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Other\"" package.json 2>/dev/null) \\
  && ok "license is Other" \\
  || miss "license drift — was Other at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "CONTRIBUTING.md" \\
  && ok "CONTRIBUTING.md" \\
  || miss "missing critical file: CONTRIBUTING.md"
test -f ".github/workflows/ci_workflow.yml" \\
  && ok ".github/workflows/ci_workflow.yml" \\
  || miss "missing critical file: .github/workflows/ci_workflow.yml"
test -f "topics/devops/README.md" \\
  && ok "topics/devops/README.md" \\
  || miss "missing critical file: topics/devops/README.md"
test -f "scripts/aws s3 event triggering/requirements.txt" \\
  && ok "scripts/aws s3 event triggering/requirements.txt" \\
  || miss "missing critical file: scripts/aws s3 event triggering/requirements.txt"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 163 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~133d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/bregman-arie/devops-exercises"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.