Live & direct // next live cohort · max 10

Python & Kubernetes for Beginners: From Zero to Cloud in 4 Weeks

Intensive, live training with limited seats — go from your first Python script to deploying real applications on a Kubernetes cluster.

300 €

Price

24h

Live training

Next cohort

Start

Beginner

Level

./view-curriculum

~/anttech/deploy.sh

$ python3 script.py
✓ API initialized
$ docker build -t app:v1 .
✓ Image built
$ kubectl apply -f cluster.yaml
✓ Pod running on anttech-prod

cluster · anttech-prod 8/8 ready

pod-01

pod-02

pod-03

pod-04

pod-05

pod-06

pod-07

pod-08

Weeks

Live classes

Hours

Seats only

📅 Next cohort: date confirmed on registration 🕕 Tue & Thu · 18:00–21:00 ☁ Online, live · max 10 people

[ curriculum ]

The full path, class by class

Eight live classes across four weeks. Pick a week, then open any class for the exact topics covered.

Python Foundations for DevOps

WK.01

Learn Python fundamentals focused on automation and API development.

01 Introduction to Python & scripting ›

Fundamentals

Install Python 3.x and set up the dev environment
VS Code as IDE: recommended Python extensions
Basic syntax: variables, data types & operators
Control flow: if/else, for & while loops

Functions & modules

Defining & using functions with params and return
Importing standard modules: os, sys, json
File handling: reading & writing files

Practice

Your first script: automating system tasks
Exercise: a script that organizes files by extension

02 Building a REST API with Flask ›

Intro to APIs

What a REST API is and why it matters in DevOps
HTTP methods: GET, POST, PUT, DELETE
HTTP status codes & best practices

Flask

Install Flask & create a virtual environment (venv)
Structure of a professional Flask project
Defining routes and endpoints
Handling JSON: request & response

Practice

Build a full CRUD API for task management
Test the API with Postman or curl
Generate requirements.txt for dependencies

Containers with Docker

WK.02

Master Docker to package and distribute applications.

03 Docker fundamentals & Dockerfiles ›

Core concepts

What Docker is and how it differs from VMs
Docker architecture: daemon, client, registry
Installing Docker on Windows, Mac & Linux
Docker Hub: find & pull official images

Essential commands

docker run, ps, stop, rm
docker images, pull, push
docker logs & exec for debugging

Dockerfile

Structure & syntax of a Dockerfile
FROM, WORKDIR, COPY, RUN, EXPOSE, CMD
Best practices: layers, cache & optimization
Multi-stage builds for lighter images

Practice

Dockerize the Flask API from week 1
Publish the image to Docker Hub

04 Networks, volumes & Docker Compose ›

Docker networking

Network types: bridge, host, none, overlay
Custom networks to connect containers
DNS resolution between containers
Port exposure: -p vs -P

Volumes & persistence

The persistence problem in containers
Volume types: named, bind mounts, tmpfs
Managing volumes: create, list, remove
Data backup & restore

Docker Compose

What Compose is and when to use it
Structure of docker-compose.yml
Define services, networks & volumes
Environment variables & .env files
Commands: up, down, logs, ps

Practice

Full stack: Flask API + PostgreSQL + Redis
Database persistence with volumes

Orchestration with Kubernetes (K8s)

WK.03

Learn to orchestrate containers at scale with Kubernetes.

05 Kubernetes architecture & first steps ›

Intro to Kubernetes

What K8s is and why it's the standard
Use cases: scaling, high availability, rollbacks
Kubernetes vs Docker Swarm vs alternatives

Cluster architecture

Control Plane: API Server, etcd, Scheduler, Controller Manager
Worker Nodes: kubelet, kube-proxy, container runtime
Communication between cluster components

Local environment

Install kubectl: the Kubernetes CLI
Minikube vs Kind vs Docker Desktop
Create your first local cluster with Minikube
Basic kubectl: get, describe, logs

Pods

What a Pod is: the smallest unit in K8s
Create Pods imperatively & declaratively (YAML)
Pod lifecycle & states
Multi-container Pods: sidecar pattern

06 Deployments, Services & exposing apps ›

Deployments

Why not use Pods directly
ReplicaSets: guaranteeing replica count
Create & manage Deployments with YAML
Update strategies: Rolling Update vs Recreate
Rollback to previous versions
Scaling: manual & automatic (intro to HPA)

Services

The dynamic-networking problem in K8s
Service types: ClusterIP, NodePort, LoadBalancer
Selectors & Labels: linking Services to Pods
K8s internal DNS for service discovery

Practice

Deploy the Flask API on K8s with 3 replicas
Create a NodePort Service to reach it from the browser
Simulate a Pod failure & watch auto-recovery

Deployment & Real-World Practice

WK.04

Advanced configuration and a final project on a real cluster.

07 ConfigMaps, Secrets & environment variables ›

Config management

Why separate config from code
12-Factor App principles applied to K8s
Environment variables in containers

ConfigMaps

What a ConfigMap is and when to use it
Create from literals, files & directories
Inject as environment variables
Mount as volumes (config files)

Secrets

Secrets vs ConfigMaps
Secret types: Opaque, docker-registry, TLS
Create & manage Secrets securely
Best practices: don't commit Secrets
Intro to Sealed Secrets & External Secrets

Practice

Configure the Flask API with ConfigMaps
Manage DB credentials with Secrets

08 Final project: full deployment & monitoring ›

Final project

Architecture: API + database + cache
Create all required YAML manifests
Namespaces: organize resources by environment
Resource Limits & Requests: CPU & memory
Liveness & Readiness Probes: health checks

Persistence in K8s

PersistentVolumes (PV) & PersistentVolumeClaims (PVC)
StorageClasses & dynamic provisioning
Deploy PostgreSQL with persistence

Basic monitoring

Observability: logs, metrics, traces
kubectl logs & aggregation tools
Intro to Prometheus & Grafana (demo)
Kubernetes Dashboard: visualize the cluster

Next steps

Cloud deployment: GKE, EKS, AKS (overview)
CI/CD with Kubernetes: GitOps & ArgoCD
Resources to keep learning
Certifications: CKA, CKAD

[ who it's for ]

One program. One price. Ten seats.

300 € flat, capped at 10 people so every question gets answered. Three starting points, one destination.

No Prior Tech Experience

Complete beginners welcome. We start from absolute zero — no coding background required.

✓Foundations from scratch
✓Guided hands-on labs
✓Personal mentor support

Developers Scaling Up

Already code? Add containers, orchestration and cloud deployment to your toolkit and ship production-grade services.

Containers

Docker & Kubernetes deep dive

CI/CD

Real CI/CD & GitOps intro

Project

Production-grade final project

300 € · 24h live · max 10

SysAdmins

Move from managing servers to orchestrating clusters and automating with Python.

✓Automation scripting
✓Cluster operations
✓Observability & monitoring

[ simple pricing ]

One investment. A career-long skillset.

No subscriptions, upsells or hidden platform fees. Everything is included in one focused cohort.

AntTech live cohort pass

300 €

Flat rate · no hidden fees

7 / 10 seats taken 3 left

Everything you need to reach production

✓8 intensive live classes
✓Direct expert mentorship
✓Final production project
✓Lifetime community access

No charge on this step

[ frequently asked ]

Clear answers. No blockers.

Everything you need to decide whether this cohort is right for you.

When are the live classes?›

Every Tuesday and Thursday from 18:00 to 21:00 Europe/Madrid time, for four weeks: 24 hours of teaching, guided labs and live troubleshooting.

What if I miss a session?›

Every session is recorded and shared with the cohort. You keep access to the recordings and can ask follow-up questions in the community.

Do I need previous experience?›

No. We start with Python fundamentals and explain every cloud-native concept from first principles. Curiosity and consistent practice are enough.

What computer do I need?›

A Windows, macOS or Linux laptop with at least 8 GB of RAM, 20 GB of free storage, stable internet and permission to install development software.

// seats are limited

Ready to start your journey to the cloud?

Capped at 10 people to guarantee personal attention. When the seats are gone, the cohort closes.