15 week DevOps with Azure Bootcamp

Demo Classes

Contact us for payment Plan

Bootcamp Details

  • Fee: 25000 INR($280 USD)
  • Total Classes: 30
  • Duration: 2.5 hours
  • Format: Live Classes
  • Starting On: 10th jan 2026
  • Classes on: Sat and Sun
  • Timings: 7-9.30 PM IST
  • Language: English

Program Overview

Goal: Transform beginners into job-ready DevOps Engineers
Schedule: 15 Weekends (Sat/Sun, 2.5 hours each).

Phase 1: Operating Systems & Version Control (Weeks 1–3)

Week 1: Linux Fundamentals

Learning Topics

  • Kernel Space vs. User Space.
  • The Shell (Bash/Zsh), Pipes, and Redirection.
  • Process Management (systemd, PID, Signals).
  • File Permissions (Octal codes, chown, chmod).

Objectives

  • Navigate the Linux filesystem hierarchy confidently.
  • Manage services and background processes.
  • Secure a Linux environment using SSH keys and user permissions.

Labs:

  1. SSH Hardening: Generate SSH keys and disable password authentication on a raw Ubuntu VM.
  2. User Management: Create a service user (webadmin) with restricted sudo access.
  3. Scripting: Write a setup.sh script to update packages, install Nginx, and serve a custom HTML file 

Resources:
https://ubuntu.com/tutorials/command-line-for-beginners#1-overview

SSH Keys and Permission

Week 2: Git & GitHub

Learning Topics

  • Git Essentials: Git Repo, Working Tree, Commit
  • Branching Strategies: Trunk-Based Development vs. GitFlow.
  • The Three States: Working Directory, Staging, and HEAD.
  • Pull Requests (PRs) and Code Reviews.

Objectives

  • Internalize the commit history structure.
  • Resolve merge conflicts.
  • Collaborate on a shared repository using modern workflow standards.

Labs:

  1. Repo Setup: Initialize devops-bootcamp-project on GitHub.
  2. Branching: Create a feature branch and modify app.py.
  3. Conflict: Introduce a conflicting change on main simultaneously.
  4. Resolution: Execute a merge, identify the conflict, resolve markers and finalize the commit.
  5. Build: Setup a Readme for your GitHub Profile page

Resources:

Git Reference Sheet: https://git-scm.com/docs

GitHub Profile Readme

Week 3: Azure Fundamentals & Governance

Learning Topics

  • Azure Resource Manager (ARM) Hierarchy (Management Groups → Resources).
  • Identity: Microsoft Entra ID (Service Principals, Managed Identities).
  • Access Control: RBAC (Role-Based Access Control).
  • Azure CLI (az) basics.

Objectives

  • Navigate the Azure Portal and CLI.
  • Understand Cloud billing (CAPEX vs. OPEX) and set budget alerts.
  • Manage resource groups and subscriptions programmatically.

Labs:

  1. Imperative Creation: Deploy a Resource Group and Linux VM using only az commands.
  2. Cost Control: Configure a Budget Alert via CLI to trigger at $10 spend.
  3. User Access Management: COnfigure users as per their role

Resources:
https://azure.microsoft.com/en-us/pricing/free-services
Organize your Azure resources effectively – Cloud Adoption Framework | Microsoft Learn

Phase 2: Containerization & Infrastructure as Code (Weeks 4–6)

Week 4: Docker & Docker Compose

Learning Topics

  • Container Primitives: Namespaces and Cgroups.
  • Images: Layer caching and Multi-stage builds.
  • Networking: Bridge networks and internal DNS.
  • Orchestration: docker-compose.yaml.

Objectives

  • Containerize a Python/Node.js application.
  • Optimize Docker images for size and security.
  • Run a multi-container stack locally.

Labs:

  1. Dockerfile: Write a Dockerfile for the Python Flask API (python:slim).
  2. Compose: Create a docker-compose.yaml to spin up Nginx (Frontend), Flask (Backend), and Redis (DB).
  3. Networking: Configure environment variables so containers communicate by service name.

Week 5: IaC with Azure Bicep

Learning Topics

  • Declarative vs. Imperative Infrastructure.
  • Bicep Syntax: Resources, Modules, and Parameters.
  • ARM Templates transpilation.
  • Idempotency.

Objectives

  • Define Azure infrastructure as code.
  • Modularize code for reusability.
  • Preview deployments using what-if.

Labs:

  1. Modules: Create vnet.bicep and webapp.bicep modules.
  2. Orchestration: Create a main.bicep that consumes modules with different parameters (dev/prod).
  3. Deployment: Deploy the stack to Azure using the CLI.

Resources:

Azure Bicep Documentation 

Week 6: IaC with Terraform

Learning Topics

  • Terraform Lifecycle: init, plan, apply, destroy.
  • State Management: terraform.tfstate, Locking, and Remote Backends.
  • HCL (HashiCorp Configuration Language) Syntax.
  • Providers and Modules.

Objectives

  • Manage infrastructure state securely.
  • Detecting and remediate configuration drift.
  • Migrate from Bicep concepts to Terraform’s multi-cloud approach.

Labs:

  1. Backend: Create an Azure Storage Account to store the Terraform state file remotely.
  2. Refactor: Rewrite Week 5’s Bicep resources into Terraform HCL.
  3. Drift Detection: Manually delete a resource in the Portal, run terraform plan, and observe the repair proposal.

Resources:

Terraform Basics: https://learn.hashicorp.com/terraform

Terraform AzureRM: Docs overview | hashicorp/azurerm | Terraform | Terraform Registry 

Phase 3: Platform & Networking (Weeks 7–9)

Week 7: Azure Advanced Services

Learning Topics

  • App Service Plans (Linux vs. Windows, Scaling).
  • Serverless: Azure Functions (Triggers and Bindings).
  • Azure Key Vault
  • Event-Driven Architecture.

Objectives

  • Deploy containers to Azure Web Apps.
  • Decouple application logic using queues and serverless functions.
  • Understand scaling triggers.

Labs:

  1. Queue: Provision an Azure Storage Queue.
  2. Serverless Logic: Write a Python Azure Function with a Queue Trigger to process votes.
  3. Binding: Configure an output binding to write processed data to Redis.

Resources:

Azure App Services
Azure Function

Week 8: Networking & IAM

Learning Topics

  • Hub-and-Spoke Topology.
  • VNet Peering and Private Endpoints.
  • Network Security Groups (NSGs) and ASGs.
  • Azure Bastion.

Objectives

  • Isolate resources in private subnets.
  • Securely connect VNets.
  • Access private resources without public IPs.

Labs: “The Fortress”

  1. Segmentation: Create a VNet with Public, Private, and Bastion subnets.
  2. Security: Apply NSG rules blocking all internet traffic to the Private subnet.
  3. Access: Deploy Azure Bastion and SSH into a private VM.

Resources:

Azure Virtual Network
Azure Network Security Group
Azure Bastion Host

Week 9: Mid-Term Capstone

Goal: Containerize and deploy an app to Azure PaaS using IaC.

Labs:

  1. Containerize: Build optimized Docker images for a 3-tier app.
  2. Infrastructure: Write Terraform to provision VNet, ACR, and App Service (Linux).
  3. Security: Ensure the database is only accessible via Private Endpoint/VNet Integration.
  4. Deployment: Manually deploy the container image to the App Service.
  5. Documentation: Submit a README.md and an architecture diagram.

Phase 4: Kubernetes Orchestration (Weeks 10–11)

Week 10: Kubernetes (AKS) Fundamentals

Learning Topics

  • Azure Container Registry
  • K8s Architecture: Control Plane vs. Node Pools.
  • Core Objects: Pods, Deployments, Services (ClusterIP, LoadBalancer).
  • Resources: Requests, Limits, and Probes.

Objectives

  • Provision ACR and AKS cluster using Terraform.
  • Write and apply Kubernetes Manifests (YAML).
  • Troubleshoot failing pods (CrashLoopBackOff).

Labs:

  1. Provision: Deploy ACR and AKS using the Terraform module from Week 6.
  2. Manifests: Write deployment.yaml for the Flask backend including Liveness Probes.
  3. Deploy: Apply manifests via kubectl and verify pod health.

Resources:

Azure Container Registry documentation | Microsoft Learn

Azure Kubernetes Service (AKS) documentation | Microsoft Learn

Kubernetes Basics: https://kubernetes.io/docs/tutorials/kubernetes-basics/

Week 11: Advanced Kubernetes (Ingress & Helm)

Learning Topics

  • Deployment Strategies and Scaling
  • Layer 7 Routing: Ingress Controllers (NGINX).
  • Package Management: Helm Charts.
  • TLS termination and DNS.

Objectives

  • Route traffic based on URL paths.
  • Package applications for repeatable deployment.
  • Manage complex dependencies with Helm.

Labs:

  1. Ingress: Install NGINX Ingress Controller using Helm.
  2. Helm Chart: Create a custom chart for the Demo app.
  3. Routing: Define Ingress rules to route /api to Backend and / to Frontend

Resources:

Concepts – Services in Azure Kubernetes Services (AKS) – Azure Kubernetes Service | Microsoft Learn

Concepts – Ingress Networking in Azure Kubernetes Service (AKS) – Azure Kubernetes Service | Microsoft Learn

Phase 5: DevOps Automation & Observability (Weeks 12–15)

Week 12: CI/CD with Azure DevOps

Learning Topics

  • CI/CD Concepts: Integration vs. Delivery.
  • ADO Pipelines (YAML): Tasks, Stages, Triggers.
  • Service Connections (Workload Identity Federation).

Objectives

  • Automate the build and push process.
  • Securely connect pipelines to Azure without long-lived keys.

Labs: The ADO Pipeline

  1. Pipeline: Create azure-pipelines.yml.
  2. Tasks: Configure tasks to Lint code, Build Docker image, and Push to ACR.
  3. Triggers: Enable triggers on commits to the main branch

Resources:
Azure DevOps

Week 13: CI/CD with GitHub Actions & GitOps Prep

Learning Topics

  • GitHub Actions: Workflows, Jobs, Steps.
  • GitHub Secrets and Environments.
  • Push vs. Pull Deployment Models.

Objectives

  • Translate ADO pipelines to GitHub Actions.
  • Understand the shift to GitOps.

Labs: The GitHub Workflow

  1. Migration: Port the build pipeline to GitHub Actions (.github/workflows).
  2. Auth: Configure azure/login action with OIDC.
  3. Push Deploy: Temporarily implement a “Push to AKS” job to verify credentials

Resources:

GitOps for Azure Kubernetes Service – Azure Architecture Center | Microsoft Learn
GitHub Actions documentation – GitHub Docs

Week 14: GitOps & Observability

Learning Topics

  • GitOps Principles: Drift Detection, Reconciliation.
  • ArgoCD: App of Apps pattern.
  • Observability: Prometheus (Metrics), Grafana (Visuals), Azure Monitor.

Objectives

  • Implement a Pull-based deployment architecture.
  • Visualize cluster health and application metrics.

Labs:

  1. ArgoCD: Deploy ArgoCD to AKS.
  2. Sync: Connect ArgoCD to a k8s-manifests repo; change replica count in Git and watch AKS sync.
  3. Monitor: Deploy a Grafana dashboard displaying Pod CPU/Memory usage

Resources:

AKS  GitOps Deployment
AKS with Grafana

Week 15: Final Capstone – “Cloud Native Transformation”

Goal: Build a production-grade, automated microservices environment.

Labs:

  1. Infrastructure: Full Terraform automation (VNet, AKS, ACR, KeyVault).
  2. Application: Deploy the 3-tier  app via Helm.
  3. Automation:
  • CI: GitHub Actions builds/tests code and updates Helm version in Git.
  • CD: ArgoCD detects change and syncs AKS.
  1. Observability: Live Grafana dashboard showing request latency.
  2. Presentation: 10-minute demo of a code change flowing automatically to production

Next Steps After Completion

  1. Certifications:
    • Microsoft Certified Azure Administrator Associate
    • Microsoft Certified Azure DevOps Expert
    • Certified Kubernetes Administrator (CKA)
    • GitHub Actions Certification

Reach out for Queries, Part payment requests

  • Email:livingdevops@gmail.com
  • WhatsApp: +91 9259681620
25000 INR
Enroll

Wall of Love