INTERMEDIATE · 8 MODULES · 64 LESSONS

Kubernetes and EKS in Production

Take a containerized app to a real Kubernetes cluster and run it like production, with a lab that runs for free on your computer.

For you if
You already use Docker and want to take the next step into container orchestration.
By the end
You'll know how to deploy, scale, and secure applications on Kubernetes, and how that carries over to EKS on AWS.
You need
Docker and a terminal. Everything runs on your machine, with no cloud bill.
  1. 01Why Kubernetes And The Continuity Challenge8 LESSONS
    1. Guide introduction: the orchestrator that was missing
    2. Why Kubernetes when ECS was already enough
    3. The continuity challenge: picking up `andes-cargo-status-api` where it left off
    4. Hands-on: installing `kind` and `kubectl`
    5. Hands-on: your first cluster
    6. Cluster architecture: control plane, nodes, and `etcd`
    7. Hands-on: loading the `andes-cargo-status-api` image into the cluster
    8. Project: Andes Cargo's cluster, ready
  2. 02Pods Deployments And Services8 LESSONS
    1. Introduction: from a container to a managed workload
    2. What a Pod is, and why you rarely create one directly
    3. Deployments: ReplicaSets and the declarative control loop
    4. Hands-on: your first Pod
    5. Hands-on: `andes-cargo-status-api`'s Deployment
    6. Services: `ClusterIP`, `NodePort`, and why a Pod isn't a stable address
    7. Hands-on: exposing `status-api-service`
    8. Project: `andes-cargo-status-api` with N replicas
  3. 03Configuration Secrets Health And Autoscaling8 LESSONS
    1. Module introduction: what a Deployment alone doesn't give you
    2. ConfigMaps: separating configuration from the image
    3. Secrets: why a credential never lives in the image
    4. Hands-on: `ConfigMap` and `Secret` for `andes-cargo-status-api`
    5. Liveness, readiness, and startup probes
    6. Hands-on: real probes on `status-api-service`
    7. `HorizontalPodAutoscaler`: scaling by metrics, not by gut feeling
    8. Project: `andes-cargo-status-api` under load
  4. 04Networking Ingress And Networkpolicy8 LESSONS
    1. Module introduction: the layer that is "not batteries included"
    2. Kubernetes' networking model: every Pod, an IP
    3. `Ingress` and Gateway API: a single HTTP door for the cluster
    4. Hands-on: the entry controller on `kind` (Envoy Gateway)
    5. Hands-on: the HTTP route for `status-api-service`
    6. `NetworkPolicy`: default allow, and why that does not last
    7. Hands-on: a real `NetworkPolicy` on `andes-cargo`
    8. Project: `status-api-service` exposed and protected
  5. 05Gitops With Argocd8 LESSONS
    1. Module introduction: the other half of GitOps
    2. Pull-based GitOps: an operator that watches, not a pipeline that pushes
    3. Hands-on: Gitea in the cluster
    4. Hands-on: installing ArgoCD
    5. Anatomy of an ArgoCD `Application`
    6. Hands-on: syncing `andes-cargo-status-api` from Git
    7. Deployment strategies: rolling, blue/green, and canary
    8. Project: a Git change, reflected on its own
  6. 06Runtime Security Admission Control And Image Scanning8 LESSONS
    1. Module introduction: the gatekeeper before `etcd`
    2. What is an admission controller, and why it runs before the object exists
    3. OPA Gatekeeper: `ConstraintTemplate` and `Constraint`
    4. Hands-on: installing Gatekeeper and your first policy
    5. Kyverno: the YAML-native alternative
    6. Hands-on: the same policy, in Kyverno
    7. Hands-on: `trivy image` on `andes-cargo-status-api`
    8. Project: Andes Cargo's runtime guardrails
  7. 07Eks Specifics For Production8 LESSONS
    1. Module introduction: why this one is different from the previous six
    2. The managed control plane: what AWS runs, what you still own
    3. Node groups: managed, self-managed, and Fargate profiles
    4. Node autoscaling: Karpenter vs Cluster Autoscaler
    5. IRSA and its successor, EKS Pod Identity
    6. The AWS Load Balancer Controller: the real production front door
    7. Hands-on: the EKS YAML, shown and explained
    8. Project: Andes Cargo's migration plan, `kind` → real EKS
  8. 08Capstone Andes Cargo On Kubernetes8 LESSONS
    1. Capstone introduction
    2. Architecture review: the full cluster
    3. End-to-end walkthrough: a change that crosses the whole gate
    4. End-to-end walkthrough: a change the gate stops
    5. What this guide left representative, final honesty
    6. The continuity correction this guide leaves for the ecosystem
    7. What Andes Cargo still needs
    8. Final project: `andes-cargo-k8s/` as the capstone deliverable
Reviews

What students say

These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.

No approved reviews yet.

Be the first to share your experience!

SEC. 06 · THE STUDIO

Why this studio exists

For decades, building software belonged to technical profiles with years of training, and getting a digital product into the real world took companies months or years. No-code and AI have narrowed that gap, but the knowledge is still held by a few.

Tech Benders exists to open that knowledge up, so business teams and non-technical teams can put their ideas into production with the right technical decisions behind them. AI does what you ask of it. Without a technical base, what it builds may not scale with your company’s ecosystem, and its costs can run away over time.

The team knows the pains of large organizations and the speed at which they have to move. It brings solution architecture, data engineering, product built end to end from back end to front end, and daily work with AI. Software that solves what you need in days, not months, with the cost of AI kept in check.

Founders

The studioRead about Tech Benders →

Write to ushi@techbenders.io

Made with Wislab