Introducción
Los laboratorios de despliegue anteriores utilizaron manifiestos de Kubernetes sin procesar directamente. Helm añade una capa de empaquetado alrededor de esos manifiestos. Un Helm chart agrupa plantillas de Kubernetes relacionadas, expone configuraciones reutilizables en values.yaml e instala los objetos renderizados como una versión (release) con nombre.
En este laboratorio, construirás un pequeño chart local en lugar de descargar uno de un repositorio. Escribirás los metadatos del chart, los valores, la plantilla de Deployment y la plantilla de Service; renderizarás el chart antes de instalarlo y, finalmente, actualizarás la versión cambiando los valores. Esto mantiene el enfoque en la habilidad clave para el CKAD: comprender cómo un chart local se convierte en objetos de Kubernetes ordinarios.
Preparar un entorno de trabajo para Helm
En este paso, prepararás un namespace y confirmarás las herramientas necesarias para el flujo de trabajo de un Helm chart local.
Comienza en /home/labex/project. Este laboratorio mantiene el directorio del chart, los manifiestos generados y todos los comandos en este espacio de trabajo.
mkdir -p /home/labex/project
cd /home/labex/project
Verifica que el servidor de la API de Kubernetes sea accesible. Si la máquina virtual acaba de iniciarse y el nodo aún no está listo, espera unos segundos y vuelve a ejecutar el comando.
kubectl get nodes --request-timeout=5s
La salida esperada incluye:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Espera hasta que el Pod de red del clúster esté listo (Ready). El chart creará un Service, por lo que los Pods de la aplicación necesitan que la red del clúster esté operativa antes de que las pruebas de tráfico sean significativas.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Salida esperada:
pod/calico-node-... condition met
Crea un namespace llamado ckad-prep-helm y establécelo como el namespace actual:
kubectl create namespace ckad-prep-helm
kubectl config set-context --current --namespace=ckad-prep-helm
Confirma tanto el namespace actual como el cliente de Helm. Helm 3 funciona directamente con Kubernetes utilizando tu kubeconfig actual; no existe un componente Tiller separado en el lado del servidor.
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
helm version --short
La salida esperada incluye:
ckad-prep-helm
v...
Crear y renderizar un chart local
En este paso, crearás un Helm chart local mínimo y lo renderizarás antes de instalar nada.
El directorio de un chart tiene algunas partes importantes. Chart.yaml describe el chart en sí. values.yaml contiene la configuración predeterminada. Los archivos bajo templates/ son manifiestos de Kubernetes con expresiones de plantilla como {{ .Values.replicaCount }}. Helm reemplaza esas expresiones con valores concretos cuando renderiza o instala el chart.
Crea el directorio del chart:
mkdir -p local-web-chart/templates
Escribe Chart.yaml. El nombre del chart no es lo mismo que el nombre de la versión (release); el nombre de la versión se elige más tarde al instalar el chart.
cat > local-web-chart/Chart.yaml <<'EOF'
apiVersion: v2
name: local-web
description: A small local chart for CKAD deployment practice
type: application
version: 0.1.0
appVersion: "1.0"
EOF
Escribe values.yaml. Estos valores predeterminados controlan el número de Pods, la imagen del contenedor, los puertos del Service y el mensaje servido por la aplicación.
cat > local-web-chart/values.yaml <<'EOF'
replicaCount: 2
image:
repository: busybox
tag: "1.36"
service:
port: 80
targetPort: 8080
message: helm-v1
EOF
Crea la plantilla de Deployment. La plantilla utiliza el nombre de la versión en los nombres de los objetos y en las etiquetas (labels), de modo que el mismo chart pueda instalarse bajo diferentes nombres de versión.
cat > local-web-chart/templates/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Release.Name }}-web
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
replicas: {{ .Values.replicaCount }}
selector:
matchLabels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
template:
metadata:
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
terminationGracePeriodSeconds: 0
containers:
- name: web
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: IfNotPresent
command:
- /bin/sh
- -c
- |
mkdir -p /www
echo {{ .Values.message | quote }} > /www/index.html
httpd -f -p {{ .Values.service.targetPort }} -h /www
ports:
- containerPort: {{ .Values.service.targetPort }}
readinessProbe:
httpGet:
path: /
port: {{ .Values.service.targetPort }}
initialDelaySeconds: 1
periodSeconds: 2
EOF
Crea la plantilla de Service. Observa que el selector del Service utiliza las mismas etiquetas que la plantilla del Pod.
cat > local-web-chart/templates/service.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
name: {{ .Release.Name }}
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
selector:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
ports:
- port: {{ .Values.service.port }}
targetPort: {{ .Values.service.targetPort }}
EOF
Ejecuta helm lint para detectar problemas en la estructura del chart y en las plantillas:
helm lint ./local-web-chart
La salida esperada incluye:
1 chart(s) linted, 0 chart(s) failed
Renderiza el chart localmente. helm template imprime el YAML de Kubernetes que Helm enviaría al servidor de la API, pero no crea ningún objeto.
helm template local-web ./local-web-chart | sed -n '1,120p'
La salida esperada incluye un Service llamado local-web y un Deployment llamado local-web-web.
Instalar el chart como una versión (release)
En este paso, instalarás el chart local en el namespace ckad-prep-helm.
Instalar un chart crea una versión de Helm (Helm release). El nombre de la versión es local-web en este laboratorio. Helm registra los metadatos de la versión y Kubernetes recibe objetos ordinarios como un Deployment y un Service.
Instala el chart:
helm install local-web ./local-web-chart
La salida esperada incluye:
NAME: local-web
STATUS: deployed
Espera a que el Deployment creado por el chart esté listo:
kubectl rollout status deployment/local-web-web --timeout=120s
Salida esperada:
deployment "local-web-web" successfully rolled out
Inspecciona la versión y los objetos de Kubernetes que creó:
helm list
kubectl get deployment,service -l app.kubernetes.io/instance=local-web
La salida esperada incluye:
local-web
deployment.apps/local-web-web
service/local-web
Crea un Pod cliente y envía una solicitud al Service. Esto confirma que el chart no solo creó objetos, sino que la aplicación instalada es realmente accesible.
kubectl run chart-client --image=busybox:1.36 --restart=Never --command -- sleep 3600
kubectl wait --for=condition=Ready pod/chart-client --timeout=120s
kubectl exec chart-client -- wget -qO- http://local-web
Salida esperada:
helm-v1
Actualizar la versión con nuevos valores
En este paso, actualizarás la versión existente sobrescribiendo los valores del chart.
El chart ya contiene plantillas reutilizables. No necesitas editar los archivos de plantilla para cambiar el mensaje o el número de réplicas. helm upgrade renderiza el mismo chart de nuevo con nuevos valores, actualiza los objetos de Kubernetes y registra una nueva revisión de la versión.
Actualiza la versión para que sirva helm-v2 con tres réplicas:
helm upgrade local-web ./local-web-chart --set message=helm-v2 --set replicaCount=3
La salida esperada incluye:
Release "local-web" has been upgraded.
STATUS: deployed
Espera a que el Deployment actualizado esté listo:
kubectl rollout status deployment/local-web-web --timeout=120s
Salida esperada:
deployment "local-web-web" successfully rolled out
Inspecciona el historial de la versión y los valores almacenados actualmente con ella:
helm history local-web
helm get values local-web
La salida esperada incluye dos revisiones y los valores sobrescritos:
REVISION
1
2
message: helm-v2
replicaCount: 3
Verifica el Deployment en ejecución y la respuesta de la aplicación:
kubectl get deployment local-web-web
kubectl exec chart-client -- wget -qO- http://local-web
La salida esperada incluye:
3/3
helm-v2
Resumen
Has creado un Helm chart local a partir de metadatos, valores predeterminados y plantillas de Kubernetes. Renderizaste el chart antes de instalarlo, lo instalaste como una versión, probaste el Service y actualizaste la versión sobrescribiendo los valores. La idea clave es que Helm empaqueta el trabajo de despliegue de aplicaciones repetibles, al tiempo que produce objetos de Kubernetes ordinarios que puedes inspeccionar con kubectl.
