Saltar al contenido principal

Lab 1.1 - Primer Despliegue en Kubernetes

Objetivos del Lab​

Al final de este laboratorio, usted será capaz de:

  • Desplegar su primera aplicación en Kubernetes
  • Utilizar kubectl para crear recursos
  • Comprender los Pods y Deployments
  • Verificar el estado de su despliegue
  • Acceder a su aplicación

Duración Estimada​

30-45 minutos

Requisitos Previos​

  • kubectl instalado y configurado
  • Cluster Kubernetes local funcional (minikube o kind)
  • Conexión a Internet (para descargar las imágenes Docker)

Verificación del Entorno​

Antes de comenzar, verifiquemos que todo esté listo:

# 1. Verificar kubectl
kubectl version --client

# 2. Verificar la conexión al cluster
kubectl cluster-info

# 3. Listar los nodos (debería mostrar al menos 1 nodo)
kubectl get nodes

Resultado esperado:

NAME           STATUS   ROLES           AGE   VERSION
minikube       Ready    control-plane   5m    v1.28.0

Si ve un error, regrese al Capítulo 1 para configurar su entorno.

Parte 1: Despliegue Simple con kubectl​

Paso 1: Crear un Pod Simple​

Comencemos creando un Pod simple que ejecute nginx:

kubectl run nginx-pod --image=nginx:latest

Explicación:

  • kubectl run: Comando para crear un Pod
  • nginx-pod: Nombre del Pod
  • --image=nginx:latest: Imagen Docker a utilizar

Paso 2: Verificar el Pod​

Verifiquemos que el Pod haya sido creado:

kubectl get pods

Resultado esperado:

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          30s

Explicación de las columnas:

  • NAME: Nombre del Pod
  • READY: Número de contenedores listos / número total (1/1 = listo)
  • STATUS: Estado del Pod (Running = en ejecución)
  • RESTARTS: Número de reinicios
  • AGE: Tiempo desde la creación

Paso 3: Obtener Más Detalles​

Para ver más información sobre el Pod:

kubectl describe pod nginx-pod

Este comando muestra:

  • Los eventos del Pod
  • El estado de los contenedores
  • Los recursos asignados
  • Los labels y anotaciones

Paso 4: Ver los Logs​

Consulte los logs del Pod:

kubectl logs nginx-pod

Debería ver los logs del servidor nginx.

Paso 5: Ejecutar un Comando en el Pod​

Ejecutemos un comando dentro del Pod:

kubectl exec -it nginx-pod -- /bin/bash

Explicación:

  • exec: Ejecutar un comando en un contenedor
  • -it: Modo interactivo con terminal
  • -- /bin/bash: Comando a ejecutar

Una vez dentro del Pod, pruebe:

# Ver el contenido del directorio
ls -la

# Verificar que nginx funciona
curl localhost

# Salir del Pod
exit

Paso 6: Eliminar el Pod​

Eliminemos el Pod que acabamos de crear:

kubectl delete pod nginx-pod

Verifiquemos que ha sido eliminado:

kubectl get pods

Parte 2: Despliegue con un Archivo YAML​

Ahora, creemos un despliegue más profesional utilizando un archivo YAML.

Paso 1: Crear el Archivo YAML​

Cree un archivo nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80

Explicación del archivo:

  • apiVersion: Versión de la API de Kubernetes
  • kind: Tipo de recurso (Deployment)
  • metadata: Metadatos (nombre, labels)
  • spec: Especificación del despliegue
    • replicas: Número de instancias (3)
    • selector: Cómo identificar los Pods
    • template: Plantilla para crear los Pods

Paso 2: Aplicar el Despliegue​

Apliquemos el archivo YAML:

kubectl apply -f nginx-deployment.yaml

Resultado esperado:

deployment.apps/nginx-deployment created

Paso 3: Verificar el Despliegue​

Verifiquemos que el despliegue ha sido creado:

kubectl get deployments

Resultado esperado:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           30s

Explicación:

  • READY: 3/3 = 3 Pods listos de 3 deseados
  • UP-TO-DATE: 3 Pods actualizados
  • AVAILABLE: 3 Pods disponibles

Paso 4: Ver los Pods Creados​

El Deployment ha creado 3 Pods:

kubectl get pods -l app=nginx

Resultado esperado:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7d4b8c9f5c-abc12   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-def34   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-ghi56   1/1     Running   0          1m

Nota: Los nombres de los Pods se generan automáticamente con un hash único.

Paso 5: Detalles del Despliegue​

Obtengamos más información sobre el despliegue:

kubectl describe deployment nginx-deployment

Este comando muestra:

  • El número de réplicas
  • La estrategia de despliegue
  • Los eventos
  • Las condiciones

Parte 3: Exponer la Aplicación​

Ahora, expongamos la aplicación para acceder desde el exterior.

Paso 1: Crear un Service​

Cree un archivo nginx-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30080

Explicación:

  • kind: Service: Crea un Service
  • type: NodePort: Expone el servicio en un puerto de cada nodo
  • selector: Selecciona los Pods con el label app: nginx
  • nodePort: 30080: Puerto accesible desde el exterior

Paso 2: Aplicar el Service​

kubectl apply -f nginx-service.yaml

Paso 3: Verificar el Service​

kubectl get services

Resultado esperado:

NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort    10.96.123.45    <none>        80:30080/TCP   30s

Paso 4: Acceder a la Aplicación​

Con minikube:​

# Obtener la URL del servicio
minikube service nginx-service --url

# O abrir directamente en el navegador
minikube service nginx-service

Con kind:​

# Encontrar la dirección IP del nodo
kubectl get nodes -o wide

# Acceder vía http://<NODE-IP>:30080

Prueba con curl:​

# Desde su máquina
curl http://localhost:30080

# O desde un Pod
kubectl run curl-test --image=curlimages/curl --rm -it -- curl http://nginx-service

¡Debería ver la página de inicio por defecto de nginx!

Parte 4: Escalado y Actualización​

Paso 1: Aumentar el Número de Réplicas​

Aumentemos el número de Pods de 3 a 5:

kubectl scale deployment nginx-deployment --replicas=5

Verifiquemos:

kubectl get pods -l app=nginx

¡Ahora debería ver 5 Pods!

Paso 2: Reducir el Número de Réplicas​

Reduzcamos a 2 Pods:

kubectl scale deployment nginx-deployment --replicas=2

Paso 3: Actualización de la Imagen​

Actualicemos la imagen de nginx a una versión más reciente:

kubectl set image deployment/nginx-deployment nginx=nginx:1.26

Verifiquemos la actualización:

kubectl rollout status deployment/nginx-deployment

Este comando muestra el progreso del rolling update.

Paso 4: Ver el Historial de Despliegues​

kubectl rollout history deployment/nginx-deployment

Paso 5: Rollback (Opcional)​

Si algo sale mal, puede volver atrás:

kubectl rollout undo deployment/nginx-deployment

Parte 5: Limpieza​

Limpiemos los recursos creados:

# Eliminar el Service
kubectl delete -f nginx-service.yaml

# Eliminar el Deployment (también elimina los Pods)
kubectl delete -f nginx-deployment.yaml

# Verificar que todo ha sido eliminado
kubectl get all

Resumen del Lab​

En este laboratorio, usted ha:

Creado su primer Pod con kubectl
Creado un Deployment con un archivo YAML
Expuesto la aplicación con un Service NodePort
Escalado el despliegue (aumentado/reducido el número de réplicas)
Actualizado la imagen Docker
Eliminado los recursos

Preguntas de Reflexión​

  1. ¿Cuál es la diferencia entre un Pod y un Deployment?

    • Un Pod es una instancia única de un contenedor
    • Un Deployment gestiona varios Pods (réplicas) y su ciclo de vida

  2. ¿Por qué usar un Deployment en lugar de un Pod directamente?

    • El Deployment gestiona automáticamente las réplicas
    • Permite rolling updates
    • Reinicia automáticamente los Pods que fallan

  3. ¿Qué es un Service y por qué lo necesitamos?

    • Un Service expone un conjunto de Pods de manera estable
    • Proporciona balanceo de carga
    • Permite el acceso desde fuera del cluster

Próximos Pasos​

Ahora que ha desplegado su primera aplicación, está listo para:

Capítulo 2: Exploración profunda de los Pods
Módulo 2: Arquitectura detallada de Kubernetes

Recursos​

Lab creado el: Diciembre 2024