Saltar al contenido

Lección 18 de 20 · Lectura y práctica

Desplegar y Configurar en Kubernetes con Helm

Concepto claveHelm es el gestor de paquetes para Kubernetes, similar a apt para Ubuntu o pip para Python. Imagina que tu aplicación de recomendación necesita varios componentes: un servicio web, una base de datos Redis para.

Del concepto a la práctica

Taller de esta lección

Helm separa la plantilla reutilizable de los valores específicos del entorno. La decisión importante es identificar qué cambia entre pruebas y producción, por ejemplo el número de réplicas, la etiqueta de imagen y el puerto, sin duplicar manifiestos completos.

Ejemplo resuelto

Un values.yaml pequeño podría declarar:

yaml
replicaCount: 2
image: recomendador:prueba-1
servicePort: 8080

La plantilla del Deployment usa replicaCount e image; la del Service usa servicePort. Para una revisión posterior, se cambia la etiqueta a prueba-2 y se mantiene el resto. Antes de instalar, helm template debe mostrar dos réplicas y la imagen solicitada.

Pruébalo

  1. Define valores separados para entorno-prueba y entorno-produccion.

  2. Renderiza cada configuración y busca el número de réplicas, la imagen y el puerto.

  3. Compara los manifiestos: solo deben variar los campos decididos.

  4. Registra el cambio de versión del chart junto con la nueva etiqueta.

Error frecuente: escribir replicaCount en los valores, pero usar un número fijo en la plantilla. Corrígelo sustituyendo el literal por la referencia al valor y vuelve a renderizar.

Comprueba tu resultado

Configura prueba con 1 réplica y producción con 3, ambas usando recomendador:prueba-2 y puerto 8080. El resultado esperado son dos salidas renderizadas donde solo cambia replicas: 1 frente a replicas: 3, sin diferencias en imagen ni puerto.

Chart mínimo sin repositorio de ejemplo

Crea Chart.yaml con apiVersion:v2, name:cursalo-recomendador, version:0.1.0 y appVersion:catalogo-1. Los valores del ejemplo se usan en estas plantillas: Deployment con replicas={{ .Values.replicaCount }}, imagen={{ .Values.image | quote }}, etiquetas de Pod y selector app:cursalo-recomendador; Service ClusterIP con selector idéntico, port={{ .Values.servicePort }} y targetPort=5000. El proceso app.py escucha en5000 independientemente del puerto del Service.

Antes de instalar ejecuta helm lint ./chart y helm template prueba ./chart -f values-prueba.yaml; comprueba el YAML resultante con tus ojos y los validadores de tu entorno. Guarda los archivos de valores completos: prueba {replicaCount:1,image:recomendador:prueba-2,servicePort:8080} y segunda simulación {replicaCount:3,image:recomendador:prueba-2,servicePort:8080}. Son dos configuraciones de laboratorio; el nombre producción no convierte una prueba local en producción.

La versión del chart identifica su paquete; Helm también lleva revisiones de una release. Incrementarla facilita distribución, pero conservar el mismo número no impide por sí solo registrar una revisión. No dependas de un repositorio ficticio del material original. Plantillas Helm.

Secuencia de código, imagen de contenedor, pruebas, registro y despliegue de instancias idénticas.
CursaloMapa de práctica
Del código al despliegue

El código se empaqueta en una imagen y se prueba antes de publicarlo. Esa misma imagen se guarda en un registro y se usa en el despliegue. Comprobar la salud de las instancias permite detectar un fallo sin reconstruir el artefacto.

Ver la infografía en tamaño completo ↗

Concepto clave

Helm es el gestor de paquetes para Kubernetes, similar a apt para Ubuntu o pip para Python. Imagina que tu aplicación de recomendación necesita varios componentes: un servicio web, una base de datos Redis para caché, y un worker para procesar datos. Sin Helm, tendrías que crear manualmente decenas de archivos YAML para cada componente. Con Helm, empaquetas todo en un chart (un paquete reutilizable) que puedes instalar, actualizar o desinstalar con un solo comando.

La magia de Helm está en las plantillas. En lugar de escribir archivos YAML estáticos, escribes plantillas con variables. Cuando instalas el chart, Helm rellena esas variables con tus valores específicos (como el nombre del entorno o la configuración de recursos). Esto te permite tener la misma aplicación corriendo en desarrollo, staging y producción, solo cambiando los valores, no el código.

Cómo funciona en la práctica

Vamos a desplegar nuestro sistema de recomendación paso a paso. Primero, necesitas tener Helm instalado. Si usas minikube o un cluster local, puedes instalarlo con:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Luego, estructura tu proyecto. Un chart básico tiene esta estructura:

recomendacion-chart/
  Chart.yaml          # Metadatos del chart
  values.yaml         # Valores por defecto
  templates/          # Plantillas YAML
    deployment.yaml
    service.yaml
    configmap.yaml
  charts/             # Dependencias (otros charts)

Para instalar tu chart en el cluster, ejecutas:

helm install mi-recomendacion ./recomendacion-chart

Esto creará todos los recursos definidos en tus plantillas. Si necesitas cambiar algo, como aumentar la memoria del servicio web, editas values.yaml y ejecutas:

helm upgrade mi-recomendacion ./recomendacion-chart

Helm actualizará solo lo necesario, manteniendo el estado de tu aplicación.

Código en acción

Veamos un ejemplo real. Este es un fragmento de templates/deployment.yaml para nuestro servicio de recomendación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Chart.Name }}-web
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Chart.Name }}
  template:
    metadata:
      labels:
        app: {{ .Chart.Name }}
    spec:
      containers:
      - name: web
        image: {{ .Values.image.repository }}:{{ .Values.image.tag }}
        ports:
        - containerPort: {{ .Values.service.port }}
        resources:
          requests:
            memory: {{ .Values.resources.requests.memory }}
            cpu: {{ .Values.resources.requests.cpu }}
          limits:
            memory: {{ .Values.resources.limits.memory }}
            cpu: {{ .Values.resources.limits.cpu }}

Y este es el values.yaml correspondiente:

replicaCount: 2
image:
  repository: mi-registry/recomendacion-modelo
  tag: v1.0
service:
  port: 5000
resources:
  requests:
    memory: "256Mi"
    cpu: "250m"
  limits:
    memory: "512Mi"
    cpu: "500m"

Cuando Helm procesa esto, genera un Deployment con 2 réplicas, usando la imagen mi-registry/recomendacion-modelo:v1.0, exponiendo el puerto 5000, con los recursos especificados. Si quieres cambiar a 3 réplicas para producción, solo modificas replicaCount en values.yaml y ejecutas helm upgrade.

Errores comunes

Error 1: No versionar los charts. Si subes cambios sin incrementar la versión en Chart.yaml, Helm no podrá hacer seguimiento de las actualizaciones. Solución: Usa versionado semántico (v1.0.0, v1.0.1) y actualiza siempre Chart.yaml antes de empaquetar.

Error 2: Valores por defecto muy restrictivos. Si defines valores como "production" en values.yaml, será difícil reutilizar el chart en otros entornos. Solución: Usa valores genéricos en values.yaml y sobrescríbelos con --set o archivos de valores específicos (values-prod.yaml).

Error 3: No probar las plantillas antes de instalar. Un error de sintaxis en una plantilla puede desplegar recursos incorrectos. Solución: Usa helm template para renderizar las plantillas y ver el YAML generado sin instalarlo:

helm template ./recomendacion-chart

Error 4: Olvidar dependencias. Si tu chart necesita Redis, pero no lo declaras en Chart.yaml, la instalación fallará. Solución: Define dependencias en Chart.yaml y ejecuta helm dependency update.

Checklist de dominio

  • Puedo crear un chart desde cero con la estructura correcta de directorios
  • Sé usar variables en plantillas ({{ .Values.xxx }}, {{ .Chart.Name }})
  • Puedo instalar, actualizar y desinstalar charts con helm install/upgrade/uninstall
  • Sé sobrescribir valores usando --set o archivos YAML externos
  • Puedo empaquetar un chart con helm package y subirlo a un repositorio
  • Sé manejar dependencias entre charts
  • Puedo debuggear problemas usando helm template y helm get

Despliega tu sistema de recomendación con Helm en un cluster local

En este ejercicio, tomarás un sistema de recomendación básico ya containerizado y lo desplegarás en Kubernetes usando Helm.

  1. Prepara el entorno: Asegúrate de tener minikube o un cluster Kubernetes local funcionando. Instala Helm si no lo tienes.
  2. Descarga el código base: Clona este repositorio que contiene el chart incompleto: git clone https://github.com/ejemplo/recomendacion-helm.git
  3. Completa el chart: El chart tiene los siguientes archivos incompletos:
    • templates/deployment.yaml: Faltan las variables para la imagen y los recursos
    • values.yaml: Faltan valores para replicaCount y service.port
    • Chart.yaml: Faltan la versión y descripción
    Completa según la documentación en README.md.
  4. Instala el chart: Ejecuta helm install mi-recomendacion ./recomendacion-helm y verifica que todos los pods estén corriendo con kubectl get pods.
  5. Actualiza la configuración: Crea un archivo values-prod.yaml que cambie replicaCount a 3 y los límites de memoria a 1Gi. Actualiza el despliegue con helm upgrade mi-recomendacion ./recomendacion-helm -f values-prod.yaml.
  6. Verifica el funcionamiento: Expón el servicio con kubectl port-forward y prueba el endpoint de recomendaciones en tu navegador.
Pistas
  • Usa helm template para ver el YAML generado antes de instalar
  • Recuerda que los nombres en las plantillas son case-sensitive
  • Si la instalación falla, usa helm status para ver detalles

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Containerización y Despliegue de Modelos de ML con Docker y Kubernetes

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.