Modern DevOps: Cloud Infrastructure, Automation, and Platform Engineering

Explore DevOps principles, collaborative operations, Linux administration, shell scripting, and core networking and security concepts. Apply these foundations to diagnose system and connectivity issues and manage servers confidently.

• Set Up a Linux Operations Lab

  Configure a Linux virtual machine with OpenSSH, Git, a shell environment, and diagnostic utilities for hands-on operations work.

• Apply DevOps Culture to Operational Work

  Map a software delivery workflow to shared ownership, feedback loops, and blameless incident practices.

• Administer Linux Users, Processes, and Services

  Diagnose and resolve a service failure using systemd, permissions, process tools, and system logs.

• Automate Repeatable Operations with Shell Scripts

  Write a robust Bash script that validates prerequisites, performs a routine server task, and reports actionable errors.

• Build a Linux Server Operations Toolkit

  Create and document a reusable toolkit of Bash scripts for health checks, log inspection, and service recovery.

• Diagnose Network Paths and Apply Security Controls

  Trace a connectivity failure with standard Linux network tools and verify the effects of DNS, routing, firewall, and SSH configuration.

• Capstone: Diagnose and Recover a Misconfigured Server

  Restore a deliberately misconfigured Linux server by combining incident practices, system administration, shell automation, and network diagnostics.

Use Git-based workflows and Python to automate repeatable operational tasks, manage configuration, and validate infrastructure changes. Build maintainable scripts and collaborate through reviewable, traceable changes.

• Set Up a Python and Git Infrastructure Automation Workspace

  Configure a reproducible development environment with Git, Python, virtual environments, pytest, pre-commit, and Terraform.

• Manage Infrastructure Automation Through Reviewable Git Workflows

  Implement a feature-branch workflow with focused commits, pull requests, and traceable change records.

• Build Safe, Configuration-Driven Python Automation

  Create an idempotent Python CLI that reads validated configuration, supports dry runs, and logs operational outcomes.

• Project: Validate Terraform Plan Changes with Python

  Build and test a Python tool that parses Terraform plan JSON and flags infrastructure changes that violate defined policies.

• Automate Quality Gates for Infrastructure Changes

  Configure GitHub Actions to run Python tests, linting, pre-commit checks, and Terraform validation on pull requests.

• Capstone: Deliver a Reviewed Cloud Operations Automation Tool

  Deliver a tested, configuration-driven Python automation tool with safe execution controls and a complete Git-based review workflow.

Learn cloud architecture and resource management across AWS and Google Cloud, including identity, networking, compute, storage, and cost considerations. Provision and operate infrastructure using documented cloud services and secure operational practices.

• Set Up AWS, Google Cloud, and Terraform Workflows

  Configure AWS CLI, Google Cloud CLI, Terraform, and secure authentication for repeatable infrastructure work in both clouds.

• Design Cross-Cloud Identity and Access Controls

  Map workload and operator access requirements to least-privilege IAM roles and policies in AWS and Google Cloud.

• Plan Secure Cloud Network Architectures

  Design AWS and Google Cloud network topologies with segmented subnets, controlled ingress and egress, and private service access.

• Select Compute and Storage for Workloads

  Choose equivalent compute and storage services across AWS and Google Cloud using workload, resilience, security, and cost requirements.

• Project: Provision a Cross-Cloud Infrastructure Baseline

  Build reusable Terraform configurations that provision a secure network and workload-ready identity baseline in AWS and Google Cloud.

• Capstone: Deploy and Operate a Resilient Cross-Cloud Workload

  Extend the infrastructure baseline to deploy a sample workload with protected storage, operational monitoring, documented recovery procedures, and cost controls in both clouds.

Package applications and their dependencies with Docker, then explore Kubernetes concepts for deploying and managing containerized services. Configure repeatable deployments and apply service health, scaling, and security practices.

• Set Up a Local Container and Kubernetes Development Environment

  Configure Docker, kubectl, and kind to build images and run a local Kubernetes cluster.

• Build Reproducible, Production-Ready Docker Images

  Create a multi-stage Dockerfile that produces a small, non-root image for an application.

• Deploy an Application with Kubernetes Workloads and Services

  Deploy a containerized application using Kubernetes Deployments, Services, ConfigMaps, and health probes.

• Project: Containerize and Deploy a Service Locally

  Build and deploy a working application to kind using a Docker image and version-controlled Kubernetes manifests.

• Improve Service Reliability, Scaling, and Security

  Configure resource requests and limits, autoscaling, secure configuration, and rolling-update safeguards for a Kubernetes workload.

• Capstone: Deliver a Reliable Kubernetes Service

  Implement a repeatable deployment for a containerized service with health checks, scaling, and security controls, then demonstrate its behavior during an update.

Design CI/CD workflows that build, test, scan, and deploy software through controlled environments. Integrate version control, containers, and cloud infrastructure to make releases repeatable and easier to recover.

• Set Up a CI/CD Repository and Toolchain

  Configure a sample application repository with GitHub Actions, Docker, and the cloud credentials needed for pipeline execution.

• Build Reliable CI Workflows with Dependency Caching

  Create a GitHub Actions workflow that validates pull requests with reproducible builds and automated tests.

• Add Code Quality, Dependency, and Container Security Scans

  Integrate automated quality and security checks that block a build when configured risk thresholds are exceeded.

• Package and Publish Immutable Container Artifacts

  Build and publish a versioned container image whose digest can be traced to its source commit.

• Project: Implement an End-to-End CI Pipeline

  Deliver a working pull-request pipeline that tests, scans, builds, and publishes the sample application.

• Deploy Through Controlled Environments with Recovery Paths

  Configure staged cloud deployments with environment approvals, infrastructure changes, health checks, and rollback procedures.

• Capstone Project: Deliver a Production-Ready Release Pipeline

  Build and demonstrate a complete pipeline that promotes an immutable application artifact through controlled cloud environments and recovers from a failed deployment.

Use logs, metrics, traces, and alerting to understand service health and respond to operational incidents. Incorporate security checks into delivery workflows and apply platform engineering principles to provide consistent self-service capabilities for development teams.

• Set Up a Kubernetes Observability and Delivery Toolchain

  Deploy OpenTelemetry Collector, Prometheus, Grafana, Loki, Tempo, and a sample service to a Kubernetes environment.

• Instrument Services with OpenTelemetry

  Instrument a service to emit correlated traces, metrics, and structured logs through OpenTelemetry.

• Define SLOs, Dashboards, and Actionable Alerts

  Create Grafana dashboards and alert rules that measure service-level objectives and link alerts to response runbooks.

• Project: Build and Investigate an Observable Service

  Deploy an instrumented service with dashboards and alerts, then diagnose a deliberately introduced failure using its telemetry.

• Integrate Security Controls into CI/CD

  Configure a GitHub Actions pipeline to run Semgrep, Trivy, and software bill of materials generation with policy-based delivery gates.

• Build a Self-Service Golden Path

  Create a Backstage software template that provisions a service repository with standardized deployment, security, and observability configurations.

• Capstone: Deliver a Secure, Observable Platform Service

  Deliver a service through the Backstage golden path and demonstrate its security controls, operational telemetry, and response to an injected incident.

Design, deploy, and operate a cloud-hosted service that combines automation, containerization, CI/CD, security controls, and observability. Present the architecture, operational runbooks, and evidence that the service can be maintained and improved.

• Provision the DevOps Toolchain and Cloud Sandbox

  Configure a version-controlled workspace, cloud account, CLI, Terraform, container tooling, and Kubernetes access for the capstone environment.

• Design the Service Architecture and Delivery Workflow

  Produce an architecture diagram and repository plan that define the service, cloud components, deployment flow, trust boundaries, and operational requirements.

• Build Repeatable Cloud Infrastructure with Terraform

  Implement reusable Terraform configuration that provisions the service network, runtime platform, identity resources, and environment-specific settings.

• Automate Secure Container Builds and CI/CD

  Create a CI/CD pipeline that tests and scans the application, builds and signs its container image, and deploys it using least-privilege credentials.

• Project: Deploy the Cloud Service and Instrument Its Runtime

  Deploy the containerized service to the provisioned cloud environment and configure health checks, logs, metrics, traces, and actionable alerts.

• Capstone: Operate, Explain, and Improve the Cloud Service

  Demonstrate a safe deployment and recovery workflow, present the architecture and runbooks, and use operational evidence to propose a measurable improvement.