Gestionando Contenedores con Azure Kubernetes Service (AKS): Orquestación de Microservicios

🚀 Introducción a Azure Kubernetes Service (AKS)

En la era de la nube y los microservicios, la gestión de aplicaciones en contenedores se ha convertido en una tarea compleja. Aquí es donde entra en juego Kubernetes, un sistema de código abierto para automatizar el despliegue, escalado y gestión de aplicaciones en contenedores. Azure Kubernetes Service (AKS) lleva esta poderosa herramienta a la nube de Microsoft, ofreciendo un servicio gestionado que simplifica enormemente la operación de clústeres de Kubernetes.

Este tutorial te proporcionará una comprensión profunda de AKS, desde sus fundamentos hasta cómo desplegar tus propias aplicaciones y gestionarlas de forma eficiente. Prepárate para dominar la orquestación de contenedores en Azure.

¿Por qué elegir AKS para tus Contenedores?

AKS ofrece una serie de ventajas clave para desarrolladores y equipos de operaciones:

• Servicio gestionado: Azure se encarga de la gestión de los nodos maestros (control plane) de Kubernetes, lo que reduce la carga operativa. Tú solo te preocupas por los nodos de trabajador y tus aplicaciones.
• Escalabilidad automática: AKS puede escalar automáticamente tanto los pods de tu aplicación como los nodos del clúster para satisfacer la demanda.
• Integración con servicios de Azure: Se integra sin problemas con otros servicios de Azure como Azure Container Registry (ACR), Azure Monitor, Azure Active Directory, y redes virtuales.
• Rentabilidad: Pagas solo por los recursos de cómputo utilizados por tus nodos de trabajador, no por el control plane de Kubernetes.
• Seguridad: Ofrece características de seguridad robustas, incluyendo la integración con Azure Active Directory para el control de acceso basado en roles (RBAC) y la gestión de identidades de pod.

🛠️ Conceptos Fundamentales de Kubernetes y AKS

Antes de sumergirnos en la práctica, es crucial entender los componentes básicos de Kubernetes que AKS gestiona por ti.

La Arquitectura de Kubernetes

Un clúster de Kubernetes se compone principalmente de un control plane (plano de control) y nodos de trabajo.

Control Plane (Maestro)

El control plane es el cerebro del clúster. Es responsable de mantener el estado deseado del clúster, tomar decisiones de programación y responder a eventos. En AKS, este componente es completamente gestionado por Azure.

Los componentes clave del control plane incluyen:

• kube-apiserver: Expone la API de Kubernetes, el frontend del control plane.
• etcd: Un almacén de clave-valor distribuido y consistente que guarda todos los datos del clúster.
• kube-scheduler: Observa los pods recién creados sin nodos asignados y selecciona un nodo para que se ejecuten.
• kube-controller-manager: Ejecuta controladores que observan el estado actual del clúster y realizan cambios para moverlo hacia el estado deseado (ej. Controlador de replicación, controlador de nodos).

Nodos de Trabajo (Workers)

Los nodos de trabajo son máquinas virtuales (VMs) o servidores físicos donde se ejecutan tus aplicaciones en contenedores. Cada nodo de trabajo tiene los siguientes componentes:

• kubelet: Un agente que se ejecuta en cada nodo y se asegura de que los contenedores se estén ejecutando en un pod.
• kube-proxy: Un proxy de red que mantiene las reglas de red en los nodos y permite la comunicación a los pods desde dentro o fuera del clúster.
• Container Runtime: Un software que se encarga de ejecutar los contenedores (ej. Docker, containerd).

Componentes Clave de Aplicación en Kubernetes

Para gestionar tus aplicaciones, Kubernetes utiliza una serie de objetos:

• Pods: La unidad más pequeña y básica de despliegue en Kubernetes. Un pod es una abstracción de una aplicación en ejecución que contiene uno o más contenedores, almacenamiento y una dirección IP de red única. Los pods son efímeros.
• Deployments: Un controlador que proporciona actualizaciones declarativas para pods y ReplicaSets. Un Deployment describe el estado deseado para tus aplicaciones, y el controlador se encarga de que ese estado se mantenga.
• Services: Una forma abstracta de exponer una aplicación que se ejecuta en un conjunto de pods como un servicio de red. Los Services permiten que tu aplicación sea accesible y actúen como un balanceador de carga para los pods subyacentes.
• ReplicaSets: Aseguran que un número especificado de réplicas de pod estén siempre en ejecución.
• Ingress: Un objeto API que gestiona el acceso externo a los servicios en un clúster, típicamente tráfico HTTP/S. Proporciona balanceo de carga, terminación SSL y routing basado en nombres.

🚀 Creando tu Primer Clúster AKS

Ahora que tenemos claros los conceptos, es hora de crear un clúster AKS.

Prerrequisitos

Antes de empezar, asegúrate de tener lo siguiente:

1. Suscripción de Azure: Necesitarás una cuenta de Azure activa.
2. Azure CLI: Instalado y configurado en tu máquina local. Puedes verificarlo con az --version.
3. kubectl: La herramienta de línea de comandos de Kubernetes. Se instalará automáticamente con Azure CLI, o puedes instalarla manualmente con az aks install-cli.

Pasos para Crear un Clúster AKS

Usaremos Azure CLI para crear nuestro clúster. Sigue estos pasos:

1. Iniciar sesión en Azure

Abre tu terminal e inicia sesión en Azure:

az login

Esto abrirá una ventana del navegador para que inicies sesión. Una vez completado, verás tus suscripciones en la terminal.

2. Crear un Grupo de Recursos

Un grupo de recursos es un contenedor lógico para tus recursos de Azure. Crea uno para tu clúster AKS:

az group create --name myAKSResourceGroup --location eastus

Reemplaza myAKSResourceGroup por el nombre que desees y eastus por tu región preferida.

3. Crear el Clúster AKS

Ahora, crea el clúster AKS. Especificaremos un nombre para el clúster, el grupo de recursos y el número de nodos iniciales. Para este tutorial, usaremos una configuración básica de 2 nodos.

az aks create \
    --resource-group myAKSResourceGroup \
    --name myAKSCluster \
    --node-count 2 \
    --enable-managed-identity \
    --generate-ssh-keys

Este proceso puede tardar varios minutos. Sé paciente.

4. Conectarse al Clúster

Una vez que el clúster esté creado, descarga las credenciales del clúster para que kubectl pueda conectarse a él:

az aks get-credentials --resource-group myAKSResourceGroup --name myAKSCluster

Verás un mensaje indicando que las credenciales se han fusionado en tu archivo ~/.kube/config.

5. Verificar la Conexión

Ahora puedes verificar el estado de tus nodos de Kubernetes:

kubectl get nodes

Deberías ver algo similar a esto:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-12345678-vmss000000   Ready    agent   5m      v1.28.3
aks-nodepool1-12345678-vmss000001   Ready    agent   5m      v1.28.3

¡Felicidades! Tienes tu clúster AKS en funcionamiento.

✨ Desplegando Aplicaciones en AKS

Con nuestro clúster listo, es hora de desplegar una aplicación de ejemplo.

Creando un Manifiesto de Despliegue

Usaremos un archivo YAML para describir nuestro Deployment y Service. Crearemos una aplicación web simple que muestre un mensaje "Hola AKS!".

Crea un archivo llamado aks-hello-world.yaml con el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-aks-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-aks
  template:
    metadata:
      labels:
        app: hello-aks
    spec:
      containers:
      - name: hello-aks
        image: k8s.gcr.io/echoserver:1.4
        ports:
        - containerPort: 8080
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
--- # Separador de documentos YAML
apiVersion: v1
kind: Service
metadata:
  name: hello-aks-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: hello-aks

Este archivo define dos objetos:

• Un Deployment llamado hello-aks-deployment que creará 3 réplicas de un pod. Cada pod usará la imagen k8s.gcr.io/echoserver:1.4 (un servidor HTTP simple que devuelve información de la solicitud y el entorno).
• Un Service de tipo LoadBalancer que expondrá el Deployment a través de una IP pública. Redirigirá el tráfico del puerto 80 al puerto 8080 de los contenedores.

Desplegar la Aplicación

Aplica el archivo YAML a tu clúster con kubectl:

kubectl apply -f aks-hello-world.yaml

Verás una confirmación de que el deployment y el service han sido creados.

Verificar el Despliegue

1. Verificar los pods:

kubectl get pods -l app=hello-aks

Deberías ver 3 pods en estado `Running`.

2. Verificar el servicio:

kubectl get service hello-aks-service

Espera unos minutos hasta que la columna `EXTERNAL-IP` muestre una dirección IP pública. Esta es la IP de tu LoadBalancer de Azure.

NAME                TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hello-aks-service   LoadBalancer   10.0.101.123   20.123.45.678   80:32000/TCP   2m

3. Acceder a la aplicación:

   Abre un navegador y navega a la EXTERNAL-IP obtenida en el paso anterior. Deberías ver la página "Hello AKS!" con información del pod que respondió a tu solicitud.

📈 Escalabilidad y Monitorización en AKS

Una de las mayores ventajas de Kubernetes es su capacidad para escalar aplicaciones. AKS mejora esto con características de escalado y herramientas de monitorización de Azure.

Escalado Manual de Aplicaciones

Puedes escalar tu Deployment de forma manual para aumentar o disminuir el número de réplicas de pods.

kubectl scale deployment/hello-aks-deployment --replicas=5

Verifica los pods de nuevo, y verás 5 pods en ejecución:

kubectl get pods -l app=hello-aks

Escalado Automático de Pods (HPA)

Kubernetes puede escalar pods automáticamente basándose en métricas de CPU o memoria. Esto se logra con el Horizontal Pod Autoscaler (HPA).

Para habilitar el HPA, primero debes asegurarte de que Metrics Server esté ejecutándose en tu clúster (AKS lo incluye por defecto).

Ahora, crea un HPA para tu Deployment hello-aks-deployment que intente mantener el uso de CPU al 50%, escalando entre 1 y 10 réplicas:

kubectl autoscale deployment hello-aks-deployment --cpu-percent=50 --min=1 --max=10

Para ver el estado del HPA:

kubectl get hpa

Inicialmente, verás TARGETS como <unknown>/50% o el porcentaje actual de CPU. Cuando la carga de CPU de los pods aumente, el HPA añadirá más pods hasta un máximo de 10. Si la carga disminuye, reducirá los pods hasta un mínimo de 1.

Escalado Automático de Clúster (Cluster Autoscaler)

Además del HPA, AKS soporta el Cluster Autoscaler. Esta característica ajusta automáticamente el número de nodos de trabajo en tu clúster cuando:

• Hay pods pendientes que no pueden programarse debido a la falta de recursos.
• Hay nodos infrautilizados que pueden ser desmantelados y sus pods reubicados en otros nodos.

Para habilitar el Cluster Autoscaler en un clúster existente o al crearlo:

az aks update \
    --resource-group myAKSResourceGroup \
    --name myAKSCluster \
    --cluster-autoscaler-enabled \
    --min-count 1 \
    --max-count 5

Esto permitirá que tu clúster escale automáticamente entre 1 y 5 nodos de trabajo, asegurando que siempre tengas recursos para tus pods y optimizando costos.

Monitorización con Azure Monitor para Contenedores

Azure Monitor para Contenedores es una solución completa para monitorizar el rendimiento de los clústeres de Kubernetes alojados en AKS. Recopila métricas de rendimiento de controladores, nodos y contenedores.

Para habilitar la monitorización en tu clúster AKS (si no lo hiciste al crearlo):

az aks enable-addons \
    --addons monitoring \
    --name myAKSCluster \
    --resource-group myAKSResourceGroup

Una vez habilitado, puedes acceder a los datos de monitorización desde el portal de Azure:

1. Navega a tu clúster AKS en el portal de Azure.
2. En el menú de la izquierda, selecciona 'Monitorización' > 'Insights'.

Aquí podrás ver paneles detallados sobre el uso de CPU/memoria de nodos y pods, logs de contenedores, eventos de Kubernetes y mucho más. Es una herramienta invaluable para la depuración y optimización.

🔒 Seguridad en AKS

La seguridad es un pilar fundamental en cualquier entorno de producción. AKS ofrece varias características para proteger tus cargas de trabajo.

Integración con Azure Active Directory (AAD)

AKS se integra con Azure Active Directory para proporcionar autenticación de usuarios al clúster de Kubernetes. Esto permite que los usuarios y grupos de AAD se autentiquen usando sus credenciales existentes y utilicen el control de acceso basado en roles (RBAC) de Kubernetes.

Para un clúster ya creado, puedes habilitar AAD con:

az aks update \
    --resource-group myAKSResourceGroup \
    --name myAKSCluster \
    --enable-aad \
    --aad-admin-group-object-ids <ID_DEL_GRUPO_AAD>

Azure Policy para AKS

Azure Policy te permite aplicar estándares de seguridad y cumplimiento en tu clúster AKS. Puedes, por ejemplo:

• Exigir que todas las imágenes de contenedores provengan de un registro de confianza.
• Restringir los tipos de contenedores que se pueden ejecutar (ej. no permitir contenedores privilegiados).
• Asegurar que los pods tienen límites de recursos definidos.

Estas políticas se aplican en tiempo de ejecución para asegurar que tus despliegues cumplen con las directrices de seguridad de tu organización.

Redes Seguras

AKS soporta diferentes modelos de red, incluyendo Azure CNI (Container Network Interface) y Kubenet. Azure CNI asigna a cada pod una IP de una subred de red virtual de Azure, lo que permite una integración de red más avanzada, como el uso de Network Security Groups (NSGs) y Azure Firewall para controlar el tráfico hacia y desde tus pods.

🧹 Limpieza de Recursos

Una vez que hayas terminado con tu clúster AKS, es importante eliminar los recursos para evitar cargos inesperados.

1. Eliminar el HPA (opcional)

Si creaste un HPA, puedes eliminarlo:

kubectl delete hpa hello-aks-deployment

2. Eliminar la Aplicación

Borra los objetos de Kubernetes (Deployment y Service) que creaste:

kubectl delete -f aks-hello-world.yaml

3. Eliminar el Clúster AKS

Esta es la operación más importante para detener los costos. Elimina el clúster AKS:

az aks delete --resource-group myAKSResourceGroup --name myAKSCluster --yes --no-wait

El flag --no-wait hace que el comando regrese inmediatamente, pero la eliminación continuará en segundo plano.

4. Eliminar el Grupo de Recursos

Finalmente, elimina el grupo de recursos que contiene todos los demás recursos creados para este tutorial. Esto asegurará que no queden recursos huérfanos.

az group delete --name myAKSResourceGroup --yes --no-wait

✅ Conclusión

En este tutorial, hemos cubierto los fundamentos de Azure Kubernetes Service, desde la creación de un clúster hasta el despliegue de una aplicación, la gestión de la escalabilidad y la monitorización. AKS te permite aprovechar la potencia de Kubernetes con la simplicidad de un servicio gestionado en Azure, facilitando la orquestación de tus microservicios y aplicaciones en contenedores.

Ahora tienes las bases para empezar a construir y gestionar tus propias cargas de trabajo en contenedores con AKS. El camino de la orquestación es vasto, ¡pero has dado un gran paso!

¡Sigue explorando y experimentando con AKS para desbloquear todo su potencial!