DevOps · 01

Cómo encajan Docker, Kubernetes y Terraform

No compiten: cada una resuelve una capa distinta. Docker empaqueta tu app, Kubernetes la corre y la escala, Terraform crea la infraestructura donde todo eso vive.

Términos de esta página

Un resumen de cada pieza. Cada tecnología tiene su propia colección de hojas con el detalle.

DevOps: Una forma de trabajar que une desarrollo (Dev) y operación (Ops): automatizar cómo se construye, se publica y se mantiene funcionando una app.
Imagen y contenedor: Docker empaqueta la app en una imagen; un contenedor es esa imagen corriendo.
Registry: Un servidor donde se guardan imágenes para que otras máquinas las descarguen (Docker Hub, GitHub Container Registry).
Cluster: Un grupo de máquinas que Kubernetes administra como si fuera una sola.
Pod / Deployment / Service: En Kubernetes: el Pod envuelve contenedores, el Deployment mantiene N copias de un Pod, el Service les da un nombre fijo.
Infraestructura: Lo que la app necesita alrededor: redes, servidores, clusters, bases de datos, dominios. Terraform la crea desde archivos.
Producción: El entorno donde la app atiende a los usuarios reales (en contraste con desarrollo, en tu PC).
Declarativo: Las tres herramientas funcionan así: describís cómo tiene que quedar todo y la herramienta calcula qué hacer.
Despliegue (deploy): Publicar una versión de la app en un entorno, por ejemplo en el cluster.

Las capas, una dentro de otra

De afuera hacia adentro: infraestructura → cluster → Pods → contenedores → tu código.

Docker: imagen y contenedor Kubernetes: Pods, réplicas, red interna Terraform: infraestructura y plataforma

Del código a producción

El recorrido de un cambio. Terraform actúa una vez (o cuando cambia la infra); Docker y kubectl, en cada versión.

En local no hay registry ni nube: la imagen queda en tu Docker, el “cluster” es el Kubernetes de Docker Desktop y Terraform crea recursos dentro de ese cluster. Así está armado el proyecto completo.

Cuándo usar cada una

Y cuándo no hace falta.

Docker

Empaquetar y correr

Siempre que tu app vaya en contenedores: es el punto de partida.
Compose alcanza para desarrollo local y apps chicas en un solo servidor.
No reparte carga entre máquinas ni hace rolling updates.

Kubernetes

Correr en serio

Varias réplicas, autocuración, actualizaciones sin corte, varias máquinas.
Muchos servicios que se hablan entre sí.
Para una sola app chica suele ser demasiado: un PaaS o Compose alcanzan.

Terraform

Infraestructura reproducible

Crear redes, clusters, bases gestionadas, DNS, buckets, permisos… desde código.
Repetir el mismo entorno (dev, qa, prod) sin clics.
No construye imágenes ni reemplaza a kubectl para el día a día de la app.

Diccionario unificado

La misma idea con el nombre que tiene en cada herramienta.

Concepto por concepto

Concepto	Docker	Kubernetes	Terraform
Archivo de definición	`Dockerfile`, `compose.yml`	Manifiestos `*.yaml`	Archivos `*.tf`
Unidad básica	Contenedor	Pod	Resource
Aplicar cambios	`docker compose up -d`	`kubectl apply -f`	`terraform apply`
Ver antes de aplicar	—	`kubectl diff -f`	`terraform plan`
Ver qué hay	`docker ps`	`kubectl get pods`	`terraform state list`
Detalle	`docker inspect`	`kubectl describe`	`terraform state show`
Logs	`docker logs -f`	`kubectl logs -f`	`TF_LOG=DEBUG`
Entrar	`docker exec -it … sh`	`kubectl exec -it … -- sh`	`terraform console`
Borrar todo	`docker compose down`	`kubectl delete -f`	`terraform destroy`
Configuración	`environment:` / `.env`	ConfigMap	`variable` / `*.tfvars`
Secretos	`.env` fuera de git	Secret	`sensitive` + `TF_VAR_*`
Datos persistentes	Volumen	PersistentVolumeClaim	Disco / DB como resource
Encontrar otro servicio	Nombre del servicio	Nombre del Service (DNS)	Referencias `tipo.nombre.attr`
Dónde guarda “lo que hay”	El propio Docker	etcd del cluster	`terraform.tfstate`
Paquetes reutilizables	Imágenes en un registry	Charts de Helm	Módulos del Registry

Los archivos de cada una

Lo mínimo que vas a ver en un repo que usa las tres.

Docker

FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
CMD ["node", "app.js"]

Dockerfile + .dockerignore + docker-compose.yml para desarrollo.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: chanchito
spec:
  replicas: 2
  # selector + template…

Carpeta k8s/ con Deployments, Services, ConfigMaps…

Terraform

resource "kubernetes_namespace_v1" "app" {
  metadata {
    name = "chanchito"
  }
}

Carpeta infra/ con *.tf, lock file y estado remoto.