0Pricing
Azure Fundamentals · Lección

Implementación de cargas de trabajo en AKS

Cree un clúster de AKS, implemente una aplicación con varios contenedores mediante kubectl y gráficos de Helm y expóngala externamente con un servicio de Azure Load Balancer.

Implementación de cargas de trabajo en AKS es una lección gratuita de Azure Fundamentals en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Azure Fundamentals, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Azure Fundamentals incluye 4 lecciones en total.

¿Qué es Azure Kubernetes Service?

Azure Kubernetes Service (AKS) es una oferta administrada de Kubernetes en la que Microsoft opera y mantiene el plano de control (servidor de API, etcd, planificador) sin coste. Solo paga por los nodos de trabajo (VM). AKS gestiona las actualizaciones de versión de Kubernetes, la aplicación de parches al sistema operativo de los nodos, el escalado del plano de control y la integración con las redes, el almacenamiento y la identidad de Azure. Esto reduce considerablemente la carga operativa de ejecutar Kubernetes en producción.

Creación de un clúster de AKS

Cree un clúster de AKS con az aks create, especificando el número de nodos, el tamaño de las VM y las opciones de red. AKS crea automáticamente un grupo de recursos de nodos que contiene las VM, los discos administrados, las NIC y los equilibradores de carga. El modo de red recomendado es Azure CNI: cada pod obtiene una dirección IP real de la VNet, lo que permite la conectividad directa con otros servicios de Azure sin NAT.

# Create an AKS cluster with 3 nodes
az aks create \
  --name myAKSCluster \
  --resource-group MyRG \
  --location eastus \
  --node-count 3 \
  --node-vm-size Standard_D2s_v3 \
  --enable-managed-identity \
  --attach-acr mycontainerregistry \
  --network-plugin azure \
  --generate-ssh-keys

# Get kubectl credentials
az aks get-credentials --name myAKSCluster --resource-group MyRG

Pools de nodos

Los clústeres de AKS pueden tener varios pools de nodos: grupos de VM con la misma configuración. El pool de nodos del sistema ejecuta componentes críticos del sistema de Kubernetes (pods de kube-system). Los pools de nodos de usuario ejecutan las cargas de trabajo de sus aplicaciones. Separar los pools permite combinar SKU de VM —por ejemplo, un pool de propósito general para aplicaciones web y otro con GPU para cargas de trabajo de ML— y escalar cada uno de forma independiente.

# Add a GPU node pool for ML workloads
az aks nodepool add \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  --name gpupool \
  --node-count 2 \
  --node-vm-size Standard_NC6s_v3 \
  --node-taints sku=gpu:NoSchedule

# List node pools
az aks nodepool list \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  -o table

Despliegue de una aplicación multicontenedor

Despliegue una aplicación de varios niveles en AKS escribiendo archivos de manifiesto de Kubernetes independientes para cada nivel y aplicándolos con kubectl apply. Un despliegue típico incluye un Deployment para el nivel web, un Deployment para el nivel de API, Services para conectarlos, un ConfigMap para la configuración del entorno y un recurso Ingress para exponer la aplicación externamente mediante un único nombre de host.

# Apply all manifests in a directory
kubectl apply -f k8s/

# Or apply individual files
kubectl apply -f frontend-deployment.yaml
kubectl apply -f frontend-service.yaml
kubectl apply -f api-deployment.yaml
kubectl apply -f api-service.yaml
kubectl apply -f ingress.yaml

# Watch rollout status
kubectl rollout status deployment/frontend
kubectl rollout status deployment/api

Ingress y Application Gateway

Un recurso Ingress define reglas de enrutamiento HTTP que asignan nombres de host y rutas URL a servicios de backend. A diferencia de un servicio LoadBalancer (una IP externa por servicio), un único controlador Ingress gestiona todo el tráfico HTTP externo y lo enruta según las reglas. En AKS, utilice el NGINX Ingress Controller o el Application Gateway Ingress Controller (AGIC) para terminar TLS y enrutar el tráfico a varios servicios.

# Ingress routing traffic to two services by path
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
  - hosts: [myapp.contoso.com]
    secretName: myapp-tls
  rules:
  - host: myapp.contoso.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service: {name: api-svc, port: {number: 80}}
      - path: /
        pathType: Prefix
        backend:
          service: {name: frontend-svc, port: {number: 80}}

Helm Charts para empaquetar aplicaciones

Helm es el gestor de paquetes de Kubernetes. Un chart agrupa todos los manifiestos de Kubernetes de una aplicación (Deployments, Services, Ingress, ConfigMaps) en un único paquete versionado y parametrizable. helm install despliega un chart con valores específicos del entorno. El repositorio de Helm de Artifact Hub aloja miles de charts prediseñados para infraestructura habitual (NGINX, cert-manager, Prometheus, Redis).

# Add the NGINX Ingress Controller chart repo
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Install NGINX Ingress Controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --create-namespace \
  --set controller.replicaCount=2

# Install your own app chart with custom values
helm install myapp ./charts/myapp -f values-prod.yaml

Actualizaciones graduales y reversiones

Actualice un Deployment cambiando la etiqueta de la imagen del contenedor. Kubernetes realiza una actualización gradual: crea nuevos pods con la imagen actualizada y termina los antiguos progresivamente, manteniendo la aplicación disponible durante todo el proceso. Si la nueva versión presenta errores, revierta inmediatamente a la revisión anterior mediante kubectl rollout undo. Kubernetes conserva un historial configurable de revisiones para cada Deployment.

# Update the image to a new version
kubectl set image deployment/myapp \
  myapp=mycontainerregistry.azurecr.io/myapp:v2.0

# Watch the rollout progress
kubectl rollout status deployment/myapp

# View rollout history
kubectl rollout history deployment/myapp

# Rollback to the previous version
kubectl rollout undo deployment/myapp

# Rollback to a specific revision
kubectl rollout undo deployment/myapp --to-revision=2

Cluster Autoscaler

Cluster Autoscaler agrega o elimina automáticamente nodos de trabajo de un pool de nodos de AKS según la programación pendiente de pods y la utilización de los nodos. Cuando no se pueden programar pods porque todos los nodos están llenos, Cluster Autoscaler aprovisiona nodos nuevos. Cuando los nodos están infrautilizados y los pods se pueden consolidar, los drena y los elimina. Esto complementa a Horizontal Pod Autoscaler: HPA escala los pods y Cluster Autoscaler escala los nodos.

# Enable Cluster Autoscaler on the default node pool
az aks update \
  --name myAKSCluster \
  --resource-group MyRG \
  --enable-cluster-autoscaler \
  --min-count 2 \
  --max-count 10

# Update autoscaler bounds on a specific node pool
az aks nodepool update \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  --name nodepool1 \
  --enable-cluster-autoscaler \
  --min-count 3 \
  --max-count 20

Supervisión de AKS con Azure Monitor

Habilite Azure Monitor Container Insights para recopilar registros y métricas del clúster de AKS sin desplegar herramientas de supervisión de terceros. Container Insights proporciona paneles prediseñados para el estado del clúster, la CPU y la memoria de nodos y pods, los registros de contenedores y la transmisión en directo de pods. Se integra con Prometheus para recopilar métricas personalizadas y permite consultar todos los datos mediante KQL en Log Analytics.

# Enable Azure Monitor Container Insights on AKS
az aks enable-addons \
  --addons monitoring \
  --name myAKSCluster \
  --resource-group MyRG \
  --workspace-resource-id /subscriptions/.../workspaces/MyLogAnalytics

# Stream live logs from a running pod
kubectl logs -f deployment/myapp -c myapp

# Query pod resource usage
kubectl top pods --namespace default

RBAC de AKS y Azure Active Directory

Integre AKS con Microsoft Entra ID para utilizar usuarios y grupos de Azure AD con RBAC de Kubernetes. En lugar de administrar cuentas de usuario de Kubernetes independientes, asigne ClusterRole o Role bindings a los ID de objeto de Entra ID. Cuando un desarrollador ejecuta kubectl, AKS valida su token de Entra ID. Esto proporciona una administración centralizada de identidades y se integra con las directivas de acceso condicional y MFA.

# Enable Entra ID RBAC on an AKS cluster
az aks update \
  --name myAKSCluster \
  --resource-group MyRG \
  --enable-azure-rbac

# Assign a built-in AKS role to an Entra group
az role assignment create \
  --role 'Azure Kubernetes Service RBAC Reader' \
  --assignee '<Entra-Group-Object-ID>' \
  --scope /subscriptions/.../resourceGroups/MyRG/providers/Microsoft.ContainerService/managedClusters/myAKSCluster

Directivas de red para la seguridad a nivel de pod

Las directivas de red son recursos de Kubernetes que controlan qué pods pueden comunicarse entre sí. De forma predeterminada, todos los pods de un clúster pueden acceder a los demás pods; las directivas de red proporcionan un firewall a nivel de pod. En AKS, habilite Azure network policy o Calico para aplicar las directivas. Un patrón habitual es una directiva de default-deny que bloquea todo el tráfico entre pods y, después, directivas explícitas de permiso para las rutas específicas que necesita la aplicación.

# Default deny all ingress to pods in namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: production
spec:
  podSelector: {}  # Matches all pods
  policyTypes:
  - Ingress

# Allow API pods to receive from frontend pods only
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-allow-frontend
spec:
  podSelector: {matchLabels: {app: api}}
  ingress:
  - from:
    - podSelector: {matchLabels: {app: frontend}}

Comprobación rápida

Compruebe su comprensión de los conceptos de Microsoft Azure Fundamentals (AZ-900) tratados en esta lección.

Resumen de la lección

En esta lección ha aprendido que AKS es un servicio administrado de Kubernetes en el que Microsoft opera el plano de control; los Helm charts empaquetan aplicaciones de Kubernetes con varios recursos para permitir despliegues repetibles; y Cluster Autoscaler agrega y elimina nodos dinámicamente según la demanda de programación de los pods. A continuación, exploraremos los desencadenadores y los bindings de Azure Functions.

Preguntas frecuentes

¿La lección «Implementación de cargas de trabajo en AKS» es gratis?

Sí — el texto completo de «Implementación de cargas de trabajo en AKS» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Azure Fundamentals, actualiza a CoddyKit PRO. El curso de Azure Fundamentals incluye 4 lecciones en total.

¿Qué aprenderé en «Implementación de cargas de trabajo en AKS»?

Cree un clúster de AKS, implemente una aplicación con varios contenedores mediante kubectl y gráficos de Helm y expóngala externamente con un servicio de Azure Load Balancer. Practicas Azure Fundamentals con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Azure Fundamentals?

No se requiere experiencia previa. Azure Fundamentals en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Implementación de cargas de trabajo en AKS»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Azure Fundamentals?

Sí. Cada lección de Azure Fundamentals incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Azure Container Registry
  2. Azure Container Instances
  3. Conceptos de Kubernetes para Azure
  4. Implementación de cargas de trabajo en AKS
← Volver a Azure Fundamentals