16-Week Real World Project-based Azure DevOps Bootcamp

Bootcamp Details

• Fee: 30,000 INR ($330)
• Total Classes: 32 (2 classes per week)
• Duration: 2.5 hours per class
• Format: Live Classes
• Schedule: Saturday & Sunday
• Timings: 8:30 PM IST – 11 PM IST
• Language: English

Real-world Azure DevOps bootcamp with hands-on projects, live troubleshooting, and production-level scenarios. Transform from beginner to job-ready DevOps Engineer in 16 weeks.

Bootcamp Level: Beginners to Advanced

---

Phase 1: Foundation – Linux & Version Control (Weeks 1-2)

Week 1: Linux Fundamentals

Learning Topics:

• Bash Basics
• System Discovery
• File Hierarchy & Navigation
• system monitoring
• The Shell (Bash/Zsh), Pipes, and Redirection
• File Management & Viewing
• Text Editing (Nano, Vim basics)
• Package Management
• Processes & I/O
• Scripting basics

Objectives:

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

Labs:

• SSH Hardening: Generate SSH keys and disable password authentication on Ubuntu VM
• User Management: Create a service user (webadmin) with restricted sudo access
• Scripting: Write a setup.sh script to update packages, install Nginx, and serve a custom HTML file
• System Monitoring: Create a script that monitors disk usage and sends alerts

Resources:

• https://ubuntu.com/tutorials/command-line-for-beginners#1-overview
• Linux permission calculator

---

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
• Real-world collaboration workflows
• Git best practices for DevOps

Objectives:

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

Labs:

• Repo Setup: Initialize devops-bootcamp-project on GitHub
• Branching: Create a feature branch and modify application code
• Conflict: Introduce a conflicting change on main simultaneously
• Resolution: Execute a merge, identify the conflict, resolve markers and finalize the commit
• Build: Setup a professional README for your GitHub Profile page
• Tag Management: Create version tags for releases

Resources:

• Git Reference Sheet: https://git-scm.com/docs
• GitHub Profile README Guide
• Git branching visualization tool

---

Phase 2: Cloud Fundamentals (Week 3)

Week 3: Azure Fundamentals & Governance

Learning Topics:

• Cloud Computing fundamentals (IaaS, PaaS, SaaS)
• Azure Resource Manager (ARM) Hierarchy (Management Groups → Subscriptions → Resource Groups → Resources)
• Identity: Microsoft Entra ID (Service Principals, Managed Identities)
• Access Control: RBAC (Role-Based Access Control)
• Azure CLI (az) basics and Azure Portal navigation
• Azure Storage: Blob Storage, File Storage
• Azure Virtual Networks basics
• Cost Management: CAPEX vs. OPEX, Budget Alerts, Cost analysis

Objectives:

• Navigate the Azure Portal and CLI confidently
• Understand Cloud billing and set budget alerts
• Manage resource groups and subscriptions programmatically
• Create and secure basic Azure resources

Labs:

• Account Setup: Create Azure free account and configure billing alerts
• Imperative Creation: Deploy a Resource Group and Linux VM using only az commands
• Cost Control: Configure a Budget Alert via CLI to trigger at $10 spend
• User Access Management: Configure users as per their role using RBAC
• Storage: Create a Storage Account and upload files to Blob Storage
• Networking: Create a VNet with subnets and deploy a VM
• Cleanup: Script to identify and delete unused resources

Resources:

• https://azure.microsoft.com/en-us/pricing/free-services
• Organize your Azure resources effectively – Cloud Adoption Framework
• Azure CLI reference documentation

---

Phase 3: Containerization (Week 4)

Week 4: Docker & Docker Compose

Learning Topics:

• Evolution of containers and why they matter
• Container Primitives: Namespaces and Cgroups
• Docker Architecture and Lifecycle
• Images: Layer caching, Multi-stage builds, and optimization
• Networking: Bridge networks, Host networks, and internal DNS
• Volume management and data persistence
• Docker security best practices
• Docker Compose for multi-container orchestration
• Azure Container Registry (ACR)

Objectives:

• Containerize applications from scratch
• Optimize Docker images for size and security
• Run multi-container stacks locally
• Understand container networking and communication
• Push and pull images from ACR

Labs:

• Dockerfile: Write a Dockerfile for a Python Flask API (python:slim base image)
• Multi-stage Build: Create optimized production-ready Docker images
• Compose: Create a docker-compose.yaml to spin up Nginx (Frontend), Flask (Backend), and Redis (Cache)
• Networking: Configure environment variables so containers communicate by service name
• Optimization: Reduce image size from 1GB to <100MB using multi-stage builds
• ACR: Push images to Azure Container Registry
• Security: Scan images for vulnerabilities

Resources:

• Docker Documentation: https://docs.docker.com/
• Docker Compose Specification
• Azure Container Registry documentation

---

Phase 4: Azure Platform Services (Weeks 5-7)

Week 5: Azure Compute & Storage Services

Learning Topics:

• Azure Virtual Machines: Sizing, availability sets, availability zones
• VM Scale Sets (VMSS) for auto-scaling
• Azure App Service Plans (Linux vs. Windows)
• Azure Container Instances (ACI)
• Azure Storage deep dive: Blob, File, Queue, Table Storage
• Storage lifecycle management, access tiers, and replication
• Azure Backup and Site Recovery
• Load Balancing: Azure Load Balancer vs Application Gateway

Objectives:

• Deploy and manage various Azure compute services
• Understand when to use VMs vs. App Services vs. Containers
• Configure auto-scaling and load balancing
• Implement storage lifecycle policies for cost optimization

Labs:

• VM Deployment: Deploy VMs with availability sets
• VMSS: Deploy a VM Scale Set with auto-scaling rules and Load Balancer
• Load Testing: Stress test VMSS and observe auto-scaling in action
• App Service: Deploy a containerized web app to Azure App Service (Linux)
• Storage Lifecycle: Configure blob storage with lifecycle policies
• Integration: Deploy app from ACR to App Service with managed identity
• Disaster Recovery: Configure backup and test restore procedures

Resources:

• Azure Virtual Machines documentation
• Azure App Service documentation
• Azure Storage documentation

---

Week 6: Azure Networking & Security

Learning Topics:

• Azure Virtual Networks (VNet): Subnets, Address Spaces, CIDR notation
• Network Security Groups (NSGs) and Application Security Groups (ASGs)
• VNet Peering and VPN Gateway
• Hub-and-Spoke Topology
• Private Endpoints and Private Link
• Azure Bastion for secure VM access
• Azure Firewall and Azure Front Door
• Azure Key Vault for secrets management
• Azure Policy and governance

Objectives:

• Design secure, production-grade network architectures
• Isolate resources in private subnets
• Securely connect VNets across regions
• Access private resources without public IPs
• Manage secrets and certificates securely

Labs: “The Fortress”

• Network Design: Create a Hub-and-Spoke VNet topology
• Segmentation: Create subnets for Public, Private, and Bastion resources
• Security: Apply NSG rules blocking all internet traffic to the Private subnet
• Access: Deploy Azure Bastion and SSH into a private VM with no public IP
• Private Endpoint: Configure Private Endpoint for Storage Account and SQL Database
• Key Vault: Store application secrets in Key Vault and access from App Service using Managed Identity
• Monitoring: Enable Network Watcher and review traffic logs

Resources:

• Azure Virtual Network documentation
• Azure Network Security Group documentation
• Azure Bastion Host documentation
• Azure Key Vault documentation

---

Week 7: Azure Databases & Serverless

Learning Topics:

• Azure SQL Database: Tiers, DTUs, vCores
• Azure Database for PostgreSQL and MySQL
• Cosmos DB basics and use cases
• Database backup, restore, and disaster recovery
• Geo-replication and failover groups
• Azure Functions: Triggers, Bindings, and runtime
• Event-driven architecture with Azure Storage Queue, Event Grid, Service Bus
• Azure Logic Apps for workflow automation
• Durable Functions for stateful workflows

Objectives:

• Deploy and manage Azure databases
• Implement serverless architectures
• Understand event-driven patterns
• Automate workflows with serverless functions
• Design for high availability and disaster recovery

Labs:

• Database: Provision Azure SQL Database and configure firewall rules
• Disaster Recovery: Configure geo-replication and simulate failover
• Connection: Connect App Service to database using connection strings in Key Vault
• Serverless Queue Processing: Create Azure Storage Queue
• Azure Function: Write a Python Azure Function with Queue Trigger to process messages
• Event-Driven Pipeline: Build data pipeline using Storage Queue → Function → Cosmos DB
• Durable Function: Create a workflow that orchestrates multiple functions
• Monitoring: Configure Application Insights for Functions

Resources:

• Azure SQL Database documentation
• Azure Functions documentation
• Event-driven architecture patterns on Azure

---

Phase 5: Infrastructure as Code with Terraform (Weeks 8-9)

Week 8: Terraform Fundamentals

Learning Topics:

• Infrastructure as Code (IaC) fundamentals and benefits
• Terraform Lifecycle: init, plan, apply, destroy
• State Management: terraform.tfstate, Locking, and Remote Backends
• HCL (HashiCorp Configuration Language) Syntax
• Terraform Providers: AzureRM provider deep dive
• Resources, Data Sources, Variables, and Outputs
• Variable precedence and .tfvars files
• Terraform formatting and validation

Objectives:

• Manage infrastructure state securely
• Write clean, maintainable Terraform configurations
• Understand the declarative approach to infrastructure
• Store state remotely with locking

Labs:

• Installation: Install Terraform and configure Azure provider authentication
• First Resource: Create a Resource Group and Storage Account using Terraform
• Remote Backend: Configure Azure Storage Account to store the Terraform state file remotely with state locking
• Variables: Parameterize configurations using variables and tfvars files for dev/prod
• Output: Extract and display resource information using outputs
• Refactor Week 5-7: Convert previously created Azure resources to Terraform code
• State Commands: Practice terraform state list, show, mv, rm

Resources:

• Terraform Basics: https://learn.hashicorp.com/terraform
• Terraform AzureRM Provider: https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs

---

Week 9: Terraform Advanced – Modules & Best Practices

Learning Topics:

• Terraform Modules: Creating and using modules
• Module structure, inputs, outputs, and versioning
• Public modules from Terraform Registry
• Terraform workspaces for multi-environment management
• Configuration drift detection and remediation
• Terraform import for existing resources
• Lifecycle rules and meta-arguments (count, for_each, depends_on)
• Dynamic blocks and conditionals
• Terraform best practices and code organization
• Secrets management in Terraform

Objectives:

• Build reusable, modular Terraform code
• Manage multiple environments (dev, staging, prod)
• Detect and fix configuration drift
• Import manually created resources into Terraform management
• Follow Terraform best practices

Labs:

• Module Creation: Build a reusable VNet module with subnets, NSGs, and Bastion
• Multi-Environment: Deploy infrastructure to dev and prod using workspaces and separate tfvars
• Drift Detection: Manually modify resources in Portal, run terraform plan, and observe repair proposal
• Import: Import existing Azure resources into Terraform state
• Full Stack: Deploy complete infrastructure (VNet, VMs, App Service, Database, Key Vault) using modules
• CI/CD Prep: Structure Terraform code for pipeline automation
• Dynamic Configuration: Use for_each to create multiple similar resources

Resources:

• Terraform Modules: https://developer.hashicorp.com/terraform/language/modules
• Terraform Best Practices Guide
• Azure Verified Modules

---

Phase 6: Kubernetes & Container Orchestration (Weeks 10-12)

Week 10: Kubernetes Fundamentals

Learning Topics:

• Container orchestration: Why Kubernetes?
• Kubernetes Architecture: Control Plane (API Server, Scheduler, Controller Manager, etcd) vs. Worker Nodes (kubelet, kube-proxy, container runtime)
• Core Objects: Pods, ReplicaSets, Deployments
• Services: ClusterIP, NodePort, LoadBalancer
• ConfigMaps and Secrets for configuration management
• Namespaces for resource isolation and multi-tenancy
• Labels, Selectors, and Annotations
• kubectl command-line tool essentials

Objectives:

• Understand Kubernetes architecture deeply
• Deploy applications to local Kubernetes cluster
• Manage application lifecycle with Deployments
• Expose applications using Services
• Externalize configuration with ConfigMaps and Secrets

Labs:

• Local Setup: Install and configure Minikube or Kind
• First Deployment: Deploy a simple web application with 3 replicas
• Service: Expose the deployment using ClusterIP and LoadBalancer Services
• ConfigMap/Secrets: Externalize database connection strings and credentials
• Scaling: Scale deployments manually and observe pod distribution
• Updates: Perform rolling updates and rollbacks
• Troubleshooting: Debug CrashLoopBackOff and ImagePullBackOff errors

Resources:

• Kubernetes Documentation: https://kubernetes.io/docs/
• Kubernetes Basics Tutorial
• kubectl Cheat Sheet

---

Week 11: Azure Kubernetes Service (AKS) – Deployment & Management

Learning Topics:

• Azure Kubernetes Service (AKS) overview
• AKS Architecture: System node pools vs. User node pools
• AKS networking: Kubenet vs. Azure CNI
• Authentication with Azure AD and Workload Identity
• RBAC in Kubernetes
• Resource Requests, Limits, and Quality of Service (QoS)
• Liveness, Readiness, and Startup Probes
• Persistent Volumes (PV), Persistent Volume Claims (PVC), and Storage Classes
• StatefulSets for stateful applications
• Jobs and CronJobs for batch processing

Objectives:

• Provision production-ready AKS cluster using Terraform
• Deploy applications to AKS
• Configure authentication and authorization
• Manage persistent storage
• Troubleshoot common AKS issues

Labs:

• AKS Provisioning: Deploy AKS cluster with Terraform including ACR integration
• Node Pools: Configure system and user node pools with different VM sizes
• Deploy Application: Deploy a 2-tier application (frontend + backend) to AKS
• Probes: Configure health checks with liveness and readiness probes
• Storage: Deploy a database using StatefulSet with persistent storage
• Authentication: Configure Azure AD integration and test RBAC policies
• Debugging: Use kubectl logs, describe, exec to troubleshoot issues
• Scaling: Manually scale deployments and node pools

Resources:

• Azure Kubernetes Service (AKS) documentation
• AKS Best Practices
• Terraform AKS module

---

Week 12: Advanced Kubernetes – Ingress, Helm & Patterns

Learning Topics:

• Ingress Controllers: NGINX Ingress Controller
• Layer 7 routing: Host-based and path-based routing
• TLS/SSL termination with cert-manager and Let’s Encrypt
• Helm: Package manager for Kubernetes
• Helm Charts: Structure, Templates, Values, Dependencies
• Chart versioning and releases
• Horizontal Pod Autoscaling (HPA) based on CPU/memory
• Vertical Pod Autoscaling (VPA)
• Cluster Autoscaler for node scaling
• Deployment Strategies: Rolling updates, Blue-Green, Canary
• Network Policies for pod-to-pod communication control
• Pod Disruption Budgets (PDB) for high availability

Objectives:

• Implement advanced routing with Ingress
• Package applications for repeatable deployment with Helm
• Implement auto-scaling at pod and node level
• Perform zero-downtime deployments
• Secure pod-to-pod communication

Labs:

• Ingress Controller: Install NGINX Ingress Controller using Helm
• TLS/SSL: Configure cert-manager for automatic SSL certificate management with Let’s Encrypt
• Routing: Define Ingress rules to route /api to Backend and / to Frontend with custom domain
• Helm Chart Creation: Create a custom Helm chart for the demo application
• Values: Parameterize chart with values.yaml for dev/prod environments
• HPA: Configure Horizontal Pod Autoscaler based on CPU utilization (target 70%)
• Load Test: Use Apache Bench or k6 to stress test and observe auto-scaling
• Deployment Strategy: Implement a Canary deployment with traffic splitting
• Network Policy: Restrict frontend to only communicate with backend

Resources:

• NGINX Ingress Controller documentation
• Helm documentation: https://helm.sh/docs/
• cert-manager documentation
• AKS autoscaling documentation

---

Phase 7: CI/CD & DevOps Automation (Weeks 13-14)

Week 13: CI/CD with Azure DevOps – Part 1

Learning Topics:

• DevOps culture and principles
• CI/CD Concepts: Continuous Integration vs. Continuous Delivery vs. Continuous Deployment
• Azure DevOps (ADO) overview: Repos, Pipelines, Boards, Artifacts, Test Plans
• ADO Pipelines (YAML): Structure, Syntax, Tasks, Jobs, Stages
• Pipeline Triggers: CI, PR, Scheduled, Manual
• Variables and Variable Groups
• Service Connections with Workload Identity Federation (OIDC)
• Build agents: Microsoft-hosted vs. Self-hosted
• Artifact management in Azure Artifacts

Objectives:

• Build end-to-end CI pipeline in Azure DevOps
• Automate Docker image build and push to ACR
• Implement pipeline best practices and security
• Use templates for reusability

Labs: “The CI Pipeline”

• ADO Setup: Create Azure DevOps organization and project
• Repo Import: Import code from GitHub to Azure Repos
• Basic Pipeline: Create azure-pipelines.yml for building the application
• Docker Build: Add tasks to build optimized Docker image
• Image Scanning: Integrate Trivy or Aqua for vulnerability scanning
• ACR Push: Push image to ACR with semantic versioning tags
• Service Connection: Configure Workload Identity Federation (OIDC) for secure authentication
• Artifact: Publish build artifacts and Helm charts
• PR Validation: Enable PR triggers with mandatory builds
• Templates: Extract reusable pipeline templates

Resources:

• Azure DevOps documentation
• Azure Pipelines YAML schema
• Pipeline best practices

---

Week 14: CI/CD with Azure DevOps – Part 2 (Deployment to AKS)

Learning Topics:

• CD pipeline design patterns
• Multi-stage pipelines: Build → Test → Deploy
• Environment management in Azure DevOps
• Approval gates and deployment conditions
• Blue-Green and Canary deployments in pipelines
• Helm deployment automation
• Pipeline security: Secret scanning, dependency scanning
• Deployment strategies and rollback procedures
• Pipeline debugging and troubleshooting

Objectives:

• Build complete CI/CD pipeline deploying to AKS
• Implement multi-environment deployment (dev, staging, prod)
• Configure approval gates for production
• Automate Helm releases
• Implement rollback procedures

Labs: “The Complete CI/CD Pipeline”

• Multi-Stage Pipeline: Extend CI pipeline with deployment stages
• Environments: Create dev, staging, and prod environments in ADO
• Helm Deployment: Deploy to AKS using Helm charts in the pipeline
• Terraform Integration: Run Terraform from pipeline to update infrastructure
• Dev Stage: Automatic deployment to dev environment on commit to main
• Staging Stage: Automatic deployment to staging with smoke tests
• Prod Stage: Manual approval required before production deployment
• Variables: Use variable groups for environment-specific configuration
• Secrets: Retrieve secrets from Azure Key Vault in pipeline
• Rollback: Implement automated rollback on deployment failure
• Monitoring: Add pipeline analytics and reporting

Resources:

• Azure DevOps Environments
• Multi-stage pipelines documentation
• Kubernetes deployments in Azure Pipelines

---

Phase 8: GitOps, Observability & Python Automation (Week 15)

Week 15: GitOps, Observability & Python Automation

Part 1: GitOps with ArgoCD

Learning Topics:

• GitOps Principles: Declarative infrastructure, Git as single source of truth
• Pull-based vs. Push-based deployment
• ArgoCD: Architecture, components, and workflow
• ArgoCD Applications and Projects
• App of Apps pattern
• Sync strategies, policies, and health checks
• Automated drift detection and reconciliation

Objectives:

• Implement Pull-based deployment architecture
• Automate drift detection and self-healing
• Integrate ArgoCD with Azure DevOps pipelines

Labs:

• ArgoCD Installation: Deploy ArgoCD to AKS using Helm
• Git Repository: Create k8s-manifests repository with environment folders
• Application: Create ArgoCD Application pointing to the manifests repo
• Sync: Change replica count in Git and watch AKS automatically sync
• App of Apps: Implement App of Apps pattern for managing multiple microservices
• Integration: Azure DevOps updates Helm chart version, ArgoCD syncs automatically
• Rollback: Perform GitOps-based rollback by reverting Git commit

---

Part 2: Observability

Learning Topics:

• Observability fundamentals: Metrics, Logs, Traces (The Three Pillars)
• Prometheus for metrics collection
• Grafana for visualization and dashboards
• Azure Monitor and Container Insights
• Application Insights for application monitoring
• Log aggregation and analysis

Objectives:

• Implement comprehensive observability for AKS
• Create meaningful dashboards
• Set up alerting for critical metrics

Labs:

• Prometheus Setup: Deploy Prometheus using Helm with custom scrape configs
• Grafana: Deploy Grafana and configure Prometheus data source
• Dashboards: Create dashboards for:
  • Pod CPU/Memory usage
  • Request rate and latency
  • Error rates
  • Custom business metrics
• Azure Monitor: Enable Container Insights for AKS cluster
• Application Insights: Integrate Application Insights with application code
• Alerts: Configure Prometheus alerts for high CPU, high memory, and pod restarts
• Log Analysis: Query logs using Grafana Loki or Azure Log Analytics

---

Part 3: Python for DevOps Automation

Learning Topics:

• Python fundamentals for DevOps engineers
• Azure SDK for Python (azure-* libraries)
• REST API interactions with requests library
• Error handling and logging in production scripts
• Creating reusable automation modules

Objectives:

• Write Python scripts to automate cloud operations
• Build practical DevOps automation tools
• Integrate Python scripts into CI/CD pipelines

Labs: “DevOps Automation Toolkit”

• Script 1: Resource Inventory – List all Azure resources across subscriptions with tags and cost data
• Script 2: Cleanup Automation – Identify and delete unused resources (stopped VMs, unattached disks, old snapshots)
• Script 3: Cost Report Generator – Generate weekly cost reports by resource group and send via email
• Script 4: Tag Compliance Checker – Scan resources for missing required tags and generate compliance report
• Script 5: Backup Validator – Verify all critical resources have backup enabled and alert on violations
• CLI Tool: Build a custom CLI using argparse that integrates all automation scripts
• Pipeline Integration: Run Python automation scripts in Azure DevOps pipeline

---

Resources:

• ArgoCD documentation: https://argo-cd.readthedocs.io/
• Prometheus documentation
• Grafana documentation
• Azure SDK for Python documentation

---

Final Capstone Project (Week 16 – Bonus Week)

Goal: Build a production-grade, end-to-end automated microservices environment demonstrating all learned skills

Project Requirements:

1. Infrastructure (Terraform)

• Hub-and-Spoke VNet architecture with proper segmentation
• AKS cluster with system and user node pools
• Azure Container Registry (ACR)
• Azure Key Vault for secrets
• Azure SQL Database or Cosmos DB
• Azure Bastion for secure access
• All infrastructure in modular, reusable Terraform code
• Multi-environment support (dev, prod)

2. Application Architecture

• Microservices architecture (minimum 3 services: Frontend, Backend API, Background Worker)
• Containerized with optimized Docker images (<100MB where possible)
• Helm charts for each service with environment-specific values
• Health checks (liveness and readiness probes)
• Resource limits and requests configured
• Horizontal Pod Autoscaler configured

3. CI/CD Pipeline (Azure DevOps)

• CI Pipeline:
  • Code linting and unit tests
  • Docker image build with multi-stage builds
  • Image vulnerability scanning
  • Push to ACR with semantic versioning
  • Publish Helm charts to Azure Artifacts
• CD Pipeline:
  • Multi-stage deployment (dev → staging → prod)
  • Automated deployment to dev
  • Manual approval for production
  • Helm-based deployment to AKS
  • Update manifest repo for ArgoCD sync

4. GitOps (ArgoCD)

• Separate Git repository for Kubernetes manifests
• ArgoCD Applications for each microservice
• App of Apps pattern implementation
• Automated sync from Git to AKS
• Drift detection and reconciliation

5. Observability Stack

• Prometheus collecting metrics from all services
• Grafana dashboards showing:
  • Request latency (p50, p95, p99)
  • Error rates
  • Pod CPU/Memory usage
  • Custom business metrics (e.g., orders processed, users online)
• Alert rules configured for critical scenarios
• Azure Monitor integration for infrastructure monitoring

6. Security Implementation

• OIDC authentication (no long-lived secrets in pipelines)
• Network policies restricting pod-to-pod communication
• Secrets stored in Azure Key Vault
• Managed Identities for Azure resource access
• Image scanning integrated in CI pipeline
• NSGs restricting traffic to private subnets

7. Python Automation

• Cost optimization script running weekly
• Resource cleanup automation
• Custom monitoring scripts

---

Deliverables:

1. Complete source code in Azure Repos or GitHub
2. Infrastructure as Code (Terraform modules)
3. Helm charts for all services
4. Azure DevOps pipelines (YAML)
5. ArgoCD application manifests
6. Architecture diagram (network, application, CI/CD flow)
7. Comprehensive README with:
   • Architecture overview
   • Setup instructions
   • How to deploy
   • How to run locally
   • Troubleshooting guide
8. 10-minute live demo showing:
   • Make a code change in the application
   • Push to Git
   • CI pipeline runs automatically
   • Tests pass, image builds and pushes to ACR
   • Helm chart version updates
   • ArgoCD detects change and syncs to AKS
   • Observe zero-downtime rolling update
   • View metrics in Grafana dashboard
   • Trigger an alert by simulating high load

---

Evaluation Criteria:

• Code quality and organization
• Infrastructure design and modularity
• Pipeline efficiency and security
• Documentation quality
• Demo presentation and Q&A
• Troubleshooting during live demo

Presentation: Each student presents their project with Q&A session (15 minutes total)

---

Course Completion

Upon completion of all classes and the capstone project, students receive:

• Azure DevOps Engineer Certificate
• Portfolio of 20+ hands-on projects
• GitHub/Azure Repos repository showcasing all solutions
• Reference architecture diagrams and best practices documentation
• Interview preparation materials focused on Azure and Kubernetes
• Resume review and optimization
• Job placement guidance and referrals

---

What Makes This Bootcamp Different

✅ Real-world focused: Every project mirrors production scenarios, not toy examples
✅ Hands-on learning: 80% labs, 20% theory – learn by doing
✅ Modern DevOps stack: Latest Azure services, Terraform, Kubernetes, GitOps with ArgoCD
✅ Azure DevOps mastery: Deep focus on Azure DevOps Pipelines
✅ Comprehensive coverage: From Linux basics to production-grade Kubernetes
✅ Live troubleshooting: Debug real issues together in class
✅ Weekend schedule: Perfect for working professionals
✅ Lifetime access: All recordings, code, notes, and resources forever
✅ Capstone project: Build portfolio-worthy project
✅ Interview ready: Focused preparation for DevOps engineer roles

---

Prerequisites

• Basic understanding of IT concepts
• Willingness to learn and practice (most important!)
• Laptop/Desktop with:
  • 8GB+ RAM (16GB recommended)
  • 50GB+ free disk space
  • Windows/macOS/Linux OS
• Azure free account (guidance provided in Week 3 – includes $200 credits)

No prior experience with cloud, containers, or Kubernetes required!

---

Frequently Asked Questions

Q: I’m a complete beginner. Can I take this course?
A: Yes! We start from Linux basics and build up systematically. The only requirement is willingness to learn.

Q: Will I need to pay for Azure resources?
A: Azure provides $200 in free credits for new accounts. This is more than enough for the bootcamp. We also teach cost optimization.

Q: What if I miss a class?
A: All classes are recorded. You get lifetime access to recordings, so you can catch up anytime.

Q: Is this enough to get a DevOps job?
A: This bootcamp covers everything needed for junior to mid-level DevOps roles. Combined with the capstone project, you’ll have a strong portfolio.

Q: Do you provide job placement?
A: We provide interview preparation, resume review, and guidance. Job placement depends on market conditions and your effort.

Q: Can I pay in installments?
A: Yes, payment plans available. Contact us for details.

---

Reach Out for Queries

Email: livingdevops@gmail.com
WhatsApp: +91 9259681620

For: Queries, Payment Plans, Course Details, Discount Information

---

What’s Included:

• 32 live classes (2.5 hours each)
• Lifetime access to all recordings
• All code, scripts, and configuration files
• Hands-on projects and labs
• Capstone project guidance
• Certificate of completion
• Interview preparation materials
• Resume review
• Community access (Discord)