Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

DevOps with Claude Code: Terraform, EKS, ArgoCD & Helm

Name: DevOps with Claude Code: Terraform, EKS, ArgoCD & Helm
Rating: 4.4 (101 reviews)

Build & deploy 8 microservices to production on AWS — Karpenter, GitOps, CI/CD, Observability + Resume Prep

Created byPravin Mishra | AWS Certified Cloud Practitioner | Solutions Architect, Pravin Mishra

Last updated 8/2026

English

English [Auto],

What you'll learn

Deploy a real microservices app to AWS EKS using Terraform, ArgoCD, and GitHub Actions — with Claude Code writing all the infra code.
Build production-grade AWS infrastructure: VPC, EKS, RDS, ECR, Secrets Manager, ALB Ingress, and a full observability stack.
Use Claude Code to generate, review, and apply Terraform modules, Kubernetes manifests, CI/CD pipelines, and runbooks.
Implement a GitOps workflow with ArgoCD — auto-sync to dev, manual approval for prod — driven entirely by AI-generated code.
Master the AI-assisted DevOps workflow: architect, prompt, review — and ship production infrastructure without writing code yourself.

Course content

17 sections • 81 lectures • 12h 5m total length

What You Will Build — Course Overview9:13
This Course Is NOT For0:53
Verify prerequisites for this course: DevOps fundamentals including Docker, Kubernetes, Terraform, AWS Cloud, and Linux; familiarize agentic AI concepts like skills, sub-agent, and MCP server.
Your Companion Repository4:49
Join The Community0:38
DevOps engineer hired, app ready, go live on AWS6:50
Become a devops engineer and go live on AWS by building infrastructure with Terraform, deploying eight Spring Boot services to EKS, and enabling GitOps with Argo CD.
Microservices App Architecture Walkthrough9:56
Walk through the eight-service microservices architecture, highlighting config server, Eureka discovery, API gateway, MySQL-backed services, GenAI with vector store, and the DevOps stack (Helm, Argo CD, Terraform).
Repo strategy: app (read-only) vs. platform (you build this)5:00
Installing Claude Code (CLI)6:03
Clone the repositories & project setup1:35
Your first Claude Code session10:22
AWS costs, free tier & keeping your bill under $107:17
Introduction & Course Setup: Quiz
Map the Application Architecture Using Claude Code

Section Overview3:21
Install Docker Desktop1:03
Running Application Locally using Docker Compose11:28
Run eight microservices with docker compose up -d, enforcing startup order via config and discovery servers and health checks, with api gateway and observability through Eureka, Zipkin, Prometheus, and Grafana.
Important Notes by Me (Pravin Mishra)0:10
The Claude Code Setup13:56
The Jira Board — Epic 1, Pick Your First Ticket13:42
Master the Jira board workflow to pick epics and tickets, read the technical spec, and drive cloud code builds from Terraform foundations to remote state and GitOps with Argo CD.
Install Terraform and AWS CLI2:02
Connecting Claude Code to Jira11:15
Connect Claude Code to Jira via Atlassian mcp, authenticate with OAuth, and generate five pet clinic platform stories (directory structure, bootstrap, backends, providers, versions) with terraform init, validate, and fmt.
Walking Through the Code — Epic 1 Review17:13
Getting Started: Quiz
Verify Your Remote State Backend with Claude Code

What we're building — VPC stories and technical spec15:38
Concepts — all-public subnets, IGW, no NAT, EKS subnet tags, ADR-000112:14
Compare the all-public-subnet production design with the learning setup, using security groups as the perimeter, ADR-0001, and cost savings from no nat gateway.
Article 3.2b: Claude Code Does Not Always Behave the Same Way4:32
Build with Claude Code — entire VPC module23:11
Review — CIDRs, SG rules, naming, tags, EKS subnet annotations16:33
Deploy — terraform plan & apply15:10
Verify — VPC in console, subnets, route tables, security group rules6:54
Networking (VPC): Quiz
Extend the VPC Module and Verify in the AWS Console

What we're building — EKS cluster, managed node groups, OIDC6:11
Build with Claude Code — entire EKS module6:48
Install kubectl — The Kubernetes CLI2:06
Review & Deploy — IAM policies, SGs, add-on versions, terraform apply6:45
Review and deploy the EKS module by validating IAM trust policies, OIDC/IRSA setup, and add-on versions, then run terraform plan and apply to provision resources.
Verify — kubectl get nodes, check add-ons, test pod scheduling8:46
Never Upgrade EKS from the AWS Console2:32
EKS Cluster: Quiz
Verify Your EKS Cluster and Explore Node Configuration

What we're building — private ECR, ARM64 images, lifecycle policies, tag6:45
Build with Claude Code — entire ECR module5:53
Install Java 17 & Docker Desktop2:20
Review & Deploy — repo names, tag immutability, Dockerfile layers11:46
Verify — images in ECR console, pull test, scan-on-push results3:53
Verify eight ECR repositories in the petclinic-dev-namespace, confirm v1.0.0 images and scan-on-push results, and assess CVEs to maintain a secure, repeatable build workflow.
Container Registry (ECR): Quiz
Verify ECR Repositories and Inspect an Image Scan Result

What we're building — shared RDS MySQL, db.t4g.micro free tier6:31
Build with Claude Code — entire RDS module6:16
Review & Deploy — instance class, storage, backup, SG rules7:06
Review the RDS module and credential flow, ensure security group, parameter group, and lifecycle settings align across dev and prod, then deploy and collect the RDS endpoint.
Verify — connectivity from debug pod, schema initialization8:43
Verify connectivity from a debug pod inside the cluster to the RDS MySQL instance, validate credentials from Secrets Manager, and confirm utf-8mb4 parameter group is applied.
Database (RDS MySQL): Quiz
Verify Database Connectivity and Schema Initialization

What we're building — Route 53 → ALB → pod, ACM certificate9:18
Article 7.1b: Buy a Domain on Route 533:59
Build with Claude Code — entire DNS/Ingress stack10:22
Build the entire DNS and ingress stack for EKS using Terraform and Helm. Configure Route 53 hosted zone, ALB ingress, DNS records, and dev environment wiring with validation.
Review & Deploy — Ingress annotations, SSL redirect, cert validation18:11
Review and deploy the dns, certificate validation, and ingress settings across two phases, ensuring proper data source hosted zone usage, acm validation, and accurate ingress annotations for a secure alb.
Verify — hit the app via the domain name with HTTPS7:02
DNS, Ingress & TLS: Quiz
Access the Application over HTTPS and Verify the TLS Certificate

What we're building — Secrets Manager, IRSA, External Secrets Operator7:44
Build with Claude Code — entire secrets stack7:55
Review & Deploy — IRSA trust policy, ClusterSecretStore, field mappings15:20
Verify — secret in SM console, synced to K8s, consumed by pod6:51
Verify end-to-end secret management from AWS secrets manager to Kubernetes, ensuring ESO health, synced external secrets, and decoded values match across RDS credentials and OpenAI API key.
Secrets Management: Quiz
Verify the Secrets Pipeline from AWS to a Running Pod

What we're building — 8 service manifests, base + overlays, probes8:15
Build with Claude Code — all 8 service manifests11:11
Review & Deploy — labels, probes, security context, startup deps26:42
Verify — pods running, services healthy, smoke test script14:37
Verify that all eight pods and services are up, reachable, and end-to-end functional from browser to database through the ALB, API gateway, Eureka, and RDS.
Kubernetes Manifests: Quiz
Extend the Base Manifests and Verify Pod Health

What we're building — Helm chart anatomy, why Helm6:14
Build with Claude Code — entire Helm chart11:46
Review & Deploy — template logic, helm template dry-run, install/upgrade/rollbac13:24
Review and deploy with helm upgrade --install, verify templates and values merge, then deploy in startup order from config server to all services, validating rds endpoints and secrets.
Verify — same app running, compare Helm vs plain YAML5:42
Helm Charts: Quiz
Add a New Value to the Helm Chart and Verify with helm template

Requirements

Basic Linux command line and AWS familiarity required.
Familiarity with Terraform, Kubernetes experience needed

Description

What if you could deploy production-grade AWS infrastructure without writing a single line of code yourself?

That’s exactly what this course is about. You’ll take a real Spring Boot microservices application—eight services, real databases, real traffic—and push it all the way to production on AWS. Every Terraform module, every Kubernetes manifest, every CI/CD pipeline, and every runbook is generated by Claude Code. Your role is to think like an architect: write precise prompts, review the outputs, and make sure everything is production-ready.

This isn’t a step-by-step tutorial. It’s a project.

You step into the role of a DevOps engineer handed a Jira board and expected to deliver. You’ll work through real epics—networking, compute, container registry, databases, secrets, GitOps, observability—in the same sequence a real production team would follow.

What you’ll build:

A VPC with public subnets across multiple availability zones
An Amazon EKS cluster running cost-optimized Graviton ARM nodes
Amazon RDS MySQL for persistent storage
Amazon ECR with lifecycle policies and vulnerability scanning
A GitOps pipeline using ArgoCD (auto-sync for dev, manual approvals for production)
GitHub Actions CI pipelines that build, push, and trigger deployments
Secrets Manager integrated with External Secrets Operator for Kubernetes
A full observability stack with Prometheus, Grafana, Fluent Bit, and Zipkin

Why Claude Code?

AI doesn’t replace engineers—it amplifies them. But only if you know how to guide it, evaluate its output, and catch what it misses. This course focuses on building that skill in the context of a real-world project, so you walk away with both working infrastructure and a repeatable workflow.

By the end, you’ll have:

A production-ready AWS platform in your GitHub portfolio
Hands-on experience with Terraform, EKS, ArgoCD, and GitHub Actions
A repeatable, AI-assisted workflow you can apply to future projects

If you’ve been meaning to get serious about cloud infrastructure, this is where it starts.

Who this course is for:

DevOps and cloud engineers who want to use AI to build real AWS infrastructure faster — and learn by doing, not by watching slides.
Software engineers moving into DevOps who want a hands-on, project-based intro to AWS, Kubernetes, Terraform, and GitOps with ArgoCD.

DevOps with Claude Code: Terraform, EKS, ArgoCD & Helm

What you'll learn

Explore related topics

Course content

Introduction & Course Setup11 lectures • 1hr 3min

Understanding the Application9 lectures • 1hr 14min

Networking — VPC7 lectures • 1hr 34min

EKS Cluster6 lectures • 33min

Container Registry (ECR)5 lectures • 31min

Database — RDS MySQL4 lectures • 29min

DNS, Ingress & TLS5 lectures • 49min

Secrets Management4 lectures • 38min

Kubernetes Manifests (Plain YAML)4 lectures • 1hr 1min

Helm Charts4 lectures • 37min

Requirements

Description

Who this course is for: