Practical DevOps Bootcamp for All

Bridge the gap between development and operations through agile principles, automation, and true collaboration to deliver features quickly with reliability.

Navigate the devops lifecycle, a continuous loop from plan and code to build, test, release, deploy, operate, and monitor, guided by backlog, MVP, and ongoing feedback.

Learn how continuous integration, delivery, and deployment automate code merges, tests, and release readiness for small, frequent updates with reduced risk, and continuous operations maintain reliability in microservice architectures.

Master devops essentials by exploring planning with open-source tools, coding in python with git and GitHub, and deploying on Linux via AWS EC2 with Docker, Kubernetes, and GitHub Actions.

Learn how agile workflows provide visibility and coordination across developers, testers, and operations by using Scrum and Kanban boards, sprints, and continuous flow in GitHub projects.

Streamline software project management by using GitHub issues and GitHub projects to track bugs, features, and tasks within the repository, leveraging boards, milestones, labels, filters, and automation.

Create and verify a GitHub account using sign-up options (manual entry or Google social login). Enable two-factor authentication to secure the account, then explore repositories, issues, and projects.

Set up a GitHub repository, create issues, and organize work with a Kanban project board, demonstrating agile workflows, prioritization, and tracking using commits, labels, and milestones.

Explore the basics of Python and the Flask framework, and see how Python powers DevOps pipelines in web development with Django and data science libraries like Pandas and NumPy.

Explore core Python concepts, including variables, data types, operators, control flow, loops, functions, modules, and classes, and learn indentation as you prepare to build a Flask web application.

Install python from python.org, add to path, verify version, and set up VS Code; then build a restaurant bill app using variables, a calculate_bill function, and math.ceil for rounding.

Build a simple Python Flask app to learn fundamentals of DevOps, including virtual environments, pip installation, and mapping routes with the app.route decorator to create a multi-page app.

Explore what a version control system is and why it matters. Learn how git tracks changes, preserves history, supports rollback, and enables safe collaboration with branches and GitHub.

Master git basics by tracing three states—modified, staged, and committed—and how the working tree, staging area, and git directory connect to init, add, commit, push, clone, and pull on GitHub.

Learn to push a Python Flask app to GitHub by configuring Git, creating a repository, and pushing via a remote origin, using commits, main branch, and personal access tokens.

Organize DevOps course development in GitHub projects using the Kanban template, turning each section into issues with task lists, labels, assignees, and progress tracking.

Containerize your Python app and practice orchestration, monitoring, and continuous delivery on AWS EC2. Build practical cloud foundations with Linux, Docker or Podman, and AWS basics for launching EC2 instances.

Explore cloud computing, moving from on premises to scalable, pay-as-you-go services with remote access, automated backups, and global data availability on AWS, Azure, and Google Cloud.

Explore AWS, the leading cloud platform, offering pay-as-you-go pricing and scalable resources. Discover key services like S3, EC2, SQS, and VPC, plus security, availability zones, and cost optimization.

Discover how AWS structures global infrastructure with regions, availability zones, and edge locations for fault-tolerant delivery. Evaluate deployment regions by compliance, latency, cost, and service availability to optimize performance.

Assigns students a practical AWS account setup and dashboard walkthrough, guiding sign-up with email verification, billing, identity verification, and navigating regions, services, and cost management in the console.

Launch scalable compute with Amazon EC2 using AMIs and instance types, attach EBS volumes, and manage access with key pairs and security groups, including elastic IP considerations.

Launch an EC2 instance on the AWS cloud using Ubuntu 24.04 LTS, configure a key pair and security group, connect via SSH, and manage hostname and lifecycle.

Set up an AWS account, launch an EC2 instance, and grasp regions and availability zones, while noting variations in EC2 instance names across accounts and security groups, and key pairs.

Demonstrates updating cloud progress in GitHub projects by marking the AWS infrastructure task as done and closing the issue in the organization project overview.

Explore Linux fundamentals, including basic commands, file navigation, and text editors, and learn ownership, package and process management, plus a demo deploying a Python app on AWS EC2.

Learn to navigate Linux using the command line, understand the shell, and use essential commands such as echo, uname, who am i, who, uptime, and date.

Explore essential Linux terminal utilities, including clear, history, man, whatis, whereis, and which, to view manuals, recall commands, locate executables, and improve workflow.

Master directory navigation using pwd, cd, ls, mkdir, and rmdir, exploring absolute paths from root and relative paths for precise file system access.

Master essential Linux file management with a demonstration of touch, file, cp, mv, and rm, plus directory navigation using cd and mkdir.

Explore viewing and manipulating file contents with cat, tac (reverse), head, tail, more, and less; learn to combine files, redirect output, and monitor real-time log entries.

Master text editing in linux with nano and VI, learning essential shortcuts, file creation, saving, searching, cutting, pasting, and powerful navigation and replacement commands.

Explore file ownership and permissions shown by ls -l, including owner, group, size, and permissions, and learn chmod, chown, and chgrp in symbolic and octal forms.

Demonstrates managing Linux file permissions with owner and group settings, using Alex as owner and the developers group to grant read/write or read-only access for Bob and Charlie.

Explore how Linux packages work, from repositories and dependency resolution to package managers like APT, Yum, and DNF, and learn how to install and manage software efficiently.

Explore the apt package manager on Debian-based systems, learning to search, install, upgrade, and remove packages with dpkg, manage dependencies, and clean the local cache.

Explore fundamental Linux process commands, including ps, pidof, pgrep, kill, pkill, and signals, and see how to identify, filter, and terminate processes in a live demonstration.

Learn to manage Linux services with systemctl, inspect units, check status, and enable, start, restart, or reload; install and configure apache2 and verify with curl.

Deploy a Python Flask app to an AWS EC2 instance, set up Ubuntu, create and activate a virtual environment, install dependencies with pip, and run the app on port 8080.

Wrap up the Linux section by reviewing terminal basics, file and directory commands, text editors, permissions, apt package management, deploying Python on EC2 with virtual environment activation and Docker containerization.

Update the Linux for DevOps project in GitHub from in progress to done, switch from backlog to team items, and assign unassigned issues to track progress and ownership.

Learn Docker fundamentals to containerize a Python application, build and run containers, and push or pull images from remote repositories for reliable, scalable deployments.

Explore containerization basics by learning what containers are, their benefits, and how namespaces and control groups deliver portability, isolation, and rapid, consistent deployment across environments.

Explore how linux namespaces and cgroups create isolated containers by separating processes and resources, and learn namespace types like user, pid, network, ipc, mount, and uts.

Discover how Docker builds, ships, and runs containerized applications, decoupling them from infrastructure to speed delivery, and learn its history from operating system virtualization to image layering.

Explore the Docker architecture, where the CLI communicates with the daemon on the Docker host to manage images, containers, networks, and volumes, with runC handling container creation.

Explore Docker objects as the building blocks of containerized apps: images create containers, containers run as isolated processes, and networks and volumes enable communication and persistent data storage.

Discover how Docker images, as read-only templates, define environments for running apps with layered structures and a writable layer, using overlayfs and a Docker file stored in registries.

Store and share container images using a container registry and Docker Hub, examining public and private options, official and verified images, and automated builds from GitHub or Bitbucket.

Explore the Docker Hub registry to search images, understand tags and latest vs versioned tags, and create a public repository with a push workflow to publish images.

Install docker on linux with the docker.io package for a quick ubuntu setup, then verify with sudo docker --version and add your user to the docker group to avoid sudo.

Explore the docker image command, its subcommands and syntax, practice common image operations such as pull, ls, tag, history, inspect, and remove, with hands-on demonstrations.

Explore how to manage Docker images using the CLI, including pulling, tagging, inspecting, removing, pruning, and searching images like nginx and Alpine on Docker Hub.

Explore how docker containers run from read-only images by creating an executable container with the docker run command, and track their lifecycle from created to running to deleted.

Explore the Docker command line interface for managing containers, including create, start, run, ls -A, stop, and exec, with hands-on demonstrations using image, name, and tag.

Explore practical docker container management using the docker cli, including run vs create, naming, attaching terminals, background processes, exec sessions, and essential commands for stopping, removing, and publishing ports.

Create and understand a Dockerfile, a script outlining instructions to construct a Docker image—setting environment, installing dependencies, copying files—and build images with docker build using a build context.

Create a dockerfile from the nginx base image to replace index.html, apply labels and workdir, and add a health check. Build and run a container exposing port 80.

Validate dockerfiles with docker lint to catch errors and avoid root users and add image tags; then build images with docker image build, tagging, and no-cache with a dot dockerignore.

Create a container from the built docker image using docker run. Inspect the health check, labels, and port 8080 to verify nginx is running with healthy status.

Learn to test a docker image locally, retag it for Docker Hub, and push to the repository after login, using docker image tag and push commands.

Containerize a Python Flask app with Docker on Ubuntu 24.04, write a Dockerfile, build and run the image, test it, and push the container to Docker Hub.

Master containerization fundamentals with Docker, including images, containers, registries, and Docker Hub. Gain hands-on practice building Docker files, running containers, and containerizing a Python Flask app.

Update docker progress in GitHub projects by moving containerization tasks from in progress to done. Use filters to view issues assigned to you or teammates for effective team management.

Learn the fundamentals of Kubernetes, the leading container orchestration platform, to deploy and scale containerized apps using namespaces, pods, replica sets, deployments, labels, selectors, services, and YAML manifests.

Explore the limitations of containers in production, including lack of self-healing, single-server availability, scaling, load balancing, and storage constraints, and learn how orchestration addresses these issues.

Explore container orchestration to automate deployment, scaling, health checks, and self-healing across clusters. Compare Kubernetes, Swarm mode, and Mesos, and learn how declarative configurations enable robust, scalable deployments.

Explore the history and rise of Kubernetes, from Borg and Omega to the open source platform, highlighting high availability, automated scaling, declarative cluster states, and CNCF adoption.

Explore why Kubernetes leads container orchestration with open source community support, portability, vendor neutrality, and an ecosystem for monitoring, logging, security, and CI/CD across on premises, cloud, and hybrid environments.

Explore Kubernetes setup options, from native control to managed and enterprise solutions, balancing expertise, cost, and vendor support for container orchestration.

Explore the Kubernetes architecture, detailing the control plane (kube API server, etcd, controller manager, and scheduler) and node components like kubelet, kube-proxy, and the container runtime.

Learn the prerequisites for a two-node Kubernetes cluster with kubeadm, including master and worker setups. Install CRI-O, Calico, join the worker, and verify with kubectl get nodes.

Watch this demonstration to set up a two-node Kubernetes cluster on AWS EC2 using kubeadm, CRI-O, and Calico, version 1.3, covering master and worker setup and node joining.

Learn to use kubectl to create, get, describe, and delete Kubernetes resources like pods and deployments, and use kubeadm to bootstrap clusters and manage tokens and certificates.

Explore four fundamental Kubernetes objects—namespaces, pods, replica sets, and deployments—and see how they partition resources, host containers, ensure high availability, and enable rolling updates and rollbacks.

Understand how Kubernetes namespaces isolate resources and enforce quotas, enabling multi-user teams to share a cluster. Identify the four default namespaces—default, kube-node-lease, kube-public, kube-system—and their roles in isolation and governance.

Learn to manage Kubernetes namespaces with practical kubectl commands, including creating, describing, switching contexts, and cleaning up namespaces to isolate resources and enhance security.

Explore pods, the basic units in Kubernetes, as one or more containers sharing network, namespace, and storage. Understand their lifecycle from creation to termination, including scaling with additional pods.

Explore creating and managing pods with kubectl in a hands-on demo. List pods, create an nginx pod, describe and exec into it, check logs, and delete pods across namespaces.

Understand replica sets in Kubernetes to guarantee self-healing by maintaining a desired number of identical pods. Define the replica set object and monitor health to scale for high availability.

Demonstrates converting a deployment yaml to a replica set yaml via a dry run, applying the manifest, and using get, describe, and scale to manage replicas and observe self-healing pods.

Understand how a deployment in Kubernetes provides declarative updates and ensures a specified number of app instances. Explore rolling updates, rollbacks, and scaling strategies to minimize downtime.

Demonstrates deploying an nginx:latest Mydb with three replicas, and verifies deployment, replica set, and pods via kubectl commands within the practical devops bootcamp.

Explore how labels and selectors organize and target Kubernetes resources, using key-value labels on pods, deployments, and services, and match expressions like app equals frontend for automation and precise scaling.

Explore labels and selectors in Kubernetes by creating a deployment named mytest with three nginx replicas, inspecting deployment, replica set, and pods labels, and understanding how selectors control pod management.

Explore in-built Kubernetes node labels and how they define roles. Learn to view labels with kubectl and assign a worker role by labeling a worker node, then verify updates.

Create a deployment named my tip with nginx:latest and list deployments, replica sets, and pods. Use short names like deploy, rs, po, ns, and explore api resources with kubectl --help.

Explore how Kubernetes services provide a stable endpoint for pods by exposing a service IP and DNS name instead of pod IPs, enabling decoupling, simplified deployment, and load balancing.

Explore cluster IP, the default Kubernetes service, enabling internal pod communication and microservice interaction via IP or DNS while restricting external access.

Create a mid-depth nginx deployment, expose it as a cluster IP service, and verify access through the cluster IP and service name, using BusyBox to test, then clean up resources.

NodePort exposes your app on a static port across all nodes, default 30000–32767, accessible from outside via each node IP; Kubernetes configures firewall rules for external access.

Demonstrates creating a Mydb deployment with nginx:latest, exposing it as a node port service, and accessing the app via the worker node IP and port 31552.

Explore how load balancer services leverage external cloud provider balancers such as AWS ELB or Azure Load Balancer to distribute traffic to healthy pods for high availability.

Explore how to create a GKE autopilot cluster, deploy nginx with three replicas, and expose it using a load balancer to obtain an external IP.

Create a deployment with nginx and a cluster IP service, align selectors with pod labels, and verify connectivity from BusyBox via endpoints using kubectl.

Explore how the Kubernetes API acts as the central nervous system for cluster communication, and learn the five core fields—API version, kind, metadata, spec, and status—that define every resource object.

Demonstrates building a deployment and a node port service with apps v1, replicas, template, and selector to manage nginx pods and expose traffic via node port 32000 and endpoints.

Create Kubernetes resources using kubectl by generating YAML for a deployment with replicas and a node-port service, review and edit manifests, and apply them to the cluster.

Explore using kubectl explain and kubectl api resources to access Kubernetes documentation, understand resource types, namespaces vs cluster-wide scope, and build yaml manifests for pods, deployments, and more.

Deploy a containerized Python app on a two-node Kubernetes cluster by creating a DevOps namespace, deployment, and service declaratively, then troubleshoot port mappings and traffic to pods.

Demonstrates scaling a Kubernetes deployment by increasing replicas to three for continuous availability, comparing manual scaling with auto scaling options like HPA, and deploying manifests in the devops namespace.

Wraps up the Kubernetes section by covering container limitations, Kubernetes architecture, two-node cluster setup, core objects (namespaces, pods, replica sets, deployments), and YAML and kubectl best practices.

Demonstrates updating Kubernetes for orchestration in GitHub projects by using the priority board to set P0 and P1, sizes L and m, enter estimates, monitor with Prometheus, and close tasks.

Explore Prometheus, an open-source, CNCF-approved, cloud-native monitoring and alerting toolkit. Learn its architecture, time series database, and PromQL queries used with Kubernetes and other platforms.

Explore the Prometheus architecture, including the server, exporters, Pushgateway, Alertmanager, and web UI; learn scraping, service discovery, dashboards with Grafana, and best practices for resiliency and storage.

Explore core Prometheus terminologies such as targets, exporters, tsdb, promql, recording rules, alerting rules, and client libraries, followed by a hands-on demonstration.

Install Prometheus and monitor Kubernetes resources using helm and kube Prometheus stack; configure nodeport access, create monitoring namespace, verify pods and dashboards, and troubleshoot etcd, scheduler, and kube proxy health.

Finish the Prometheus monitoring section by updating a GitHub project: edit details, update the readme, set environment, and log status updates with start and target dates to stay on track.