Kubernetes · Cheatsheet 05

De Docker Compose a Kubernetes

Tu proyecto pruebas-docker (chanchito + monguito) llevado a un cluster local, paso a paso. Mismo app.js, misma imagen.

Cada línea del compose, en qué objeto se convierte

Dos servicios de compose → seis objetos de Kubernetes.

✓

El Service de Mongo se llama monguito: tu connection string @monguito:27017 sigue funcionando sin tocar app.js.

Mongo queda como ClusterIP: solo lo ve chanchito. Para entrar con Compass: kubectl port-forward svc/monguito 27017:27017.

strategy: Recreate en Mongo evita que dos Pods intenten usar el mismo disco durante una actualización.

Paso a paso

Desde la carpeta pruebas-docker, con el Kubernetes de Docker Desktop (variantes para minikube/kind al costado).

Levantar todo

# 1. Cluster encendido y apuntado
kubectl config use-context docker-desktop
kubectl get nodes

El nodo tiene que estar Ready.

# 2. Imagen de la app con tag fijo
docker build -t chanchito:1 .

Kubernetes no construye: usa imágenes ya hechas.

# 3. Secret (fuera de git)
kubectl create secret generic mongo-secret \
  --from-literal=MONGO_INITDB_ROOT_USERNAME=mati \
  --from-literal=MONGO_INITDB_ROOT_PASSWORD=<password>

Mismos valores que usa app.js en el connection string.

# 4. Aplicar los manifiestos
kubectl apply -f k8s/

≈ docker compose up -d.

# 5. Esperar a que estén Running
kubectl get pods -w

Ctrl+C cuando todos digan 1/1 Running.

Probar, ver logs y limpiar

# 6. Probar
#   http://localhost:30080/crear  -> crea un documento
#   http://localhost:30080        -> lista
kubectl port-forward svc/chanchito 3000:80   # alternativa

Por NodePort o por port-forward.

# 7. Logs de todas las réplicas
kubectl logs -l app=chanchito -f

Vas a ver “listando.. chanchitos” repartido entre los Pods.

# 8. Nueva versión
docker build -t chanchito:2 .
kubectl set image deployment/chanchito chanchito=chanchito:2
kubectl rollout status deploy/chanchito

Rolling update sin corte. Si falla: kubectl rollout undo deploy/chanchito.

# 9. Bajar todo (⚠ incluye el PVC → borra los datos)
kubectl delete -f k8s/
kubectl delete secret mongo-secret

≈ docker compose down -v. Para conservar datos, borrá solo los Deployments.

Si usás minikube o kind

minikube image load chanchito:1
minikube service chanchito --url

Cargar la imagen (después del build) · obtener la URL del NodePort.

kind load docker-image chanchito:1
kubectl port-forward svc/chanchito 3000:80

En kind los NodePort no se publican solos: usá port-forward.

Los manifiestos completos

Creá la carpeta k8s/ en pruebas-docker con estos dos archivos.

monguito.yaml

k8s/monguito.yamlPVC + Deployment + Service

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mongo-data
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: monguito
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: monguito
  template:
    metadata:
      labels:
        app: monguito
    spec:
      containers:
        - name: mongo
          image: mongo:7
          ports:
            - containerPort: 27017
          envFrom:
            - secretRef:
                name: mongo-secret   # MONGO_INITDB_ROOT_*
          volumeMounts:
            - name: datos
              mountPath: /data/db
      volumes:
        - name: datos
          persistentVolumeClaim:
            claimName: mongo-data
---
apiVersion: v1
kind: Service
metadata:
  name: monguito                     # = host del connection string
spec:
  selector:
    app: monguito
  ports:
    - port: 27017
      targetPort: 27017

chanchito.yaml

k8s/chanchito.yamlDeployment + Service

apiVersion: apps/v1
kind: Deployment
metadata:
  name: chanchito
spec:
  replicas: 2
  selector:
    matchLabels:
      app: chanchito
  template:
    metadata:
      labels:
        app: chanchito
    spec:
      containers:
        - name: chanchito
          image: chanchito:1
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 3000
          readinessProbe:
            tcpSocket:
              port: 3000
            initialDelaySeconds: 3
          resources:
            requests: { cpu: 50m, memory: 64Mi }
            limits: { memory: 256Mi }
---
apiVersion: v1
kind: Service
metadata:
  name: chanchito
spec:
  type: NodePort
  selector:
    app: chanchito
  ports:
    - port: 80
      targetPort: 3000
      nodePort: 30080                # http://localhost:30080

Si Mongo tarda en arrancar, chanchito puede fallar la primera conexión y reiniciarse un par de veces: es normal, Kubernetes lo reintenta solo (no existe depends_on).

Mejora recomendada: sacar la contraseña de app.js y leer process.env.MONGO_URL, inyectada desde el Secret.

Compose vs kubectl en el día a día

El mismo gesto en los dos mundos.

Equivalencias de comandos

Quiero…	Docker Compose	Kubernetes
Levantar todo	`docker compose up -d`	`kubectl apply -f k8s/`
Ver qué corre	`docker compose ps`	`kubectl get pods`
Logs de un servicio	`docker compose logs -f chanchito`	`kubectl logs -f deploy/chanchito`
Entrar a un contenedor	`docker compose exec chanchito sh`	`kubectl exec -it deploy/chanchito -- sh`
Reiniciar	`docker compose restart chanchito`	`kubectl rollout restart deploy/chanchito`
Más réplicas	`docker compose up --scale chanchito=3` (sin puerto fijo en el host)	`kubectl scale deploy chanchito --replicas=3`
Nueva versión	`docker compose up --build`	`docker build -t chanchito:2 .` + `kubectl set image …`
Bajar todo	`docker compose down`	`kubectl delete -f k8s/`
Ver la config final	`docker compose config`	`kubectl get deploy chanchito -o yaml`

✓

Para desarrollar en tu PC, Compose sigue siendo más cómodo (bind mount + nodemon). Kubernetes brilla al desplegar: réplicas, actualizaciones sin corte y autocuración.