Tutorial: Preparación de una aplicación para Azure Kubernetes Service (AKS)

En este tutorial, preparará una aplicación de varios contenedores para usarla en Kubernetes. Puede usar este tutorial tanto si empieza con una nueva aplicación de ejemplo como si va a adaptar los conceptos de Docker Compose para una aplicación que planea migrar a Azure Kubernetes Service (AKS). Puede usar herramientas de desarrollo existentes, como Docker Compose, para compilar y probar la aplicación localmente. Aprenderá a:

Tras finalizar, la siguiente aplicación se ejecuta en su entorno de desarrollo local:

En tutoriales posteriores, cargará la imagen de contenedor en un Azure Container Registry (ACR) y, a continuación, la implementará en un clúster de AKS.

Antes de empezar

En este tutorial se asume que el usuario tiene un conocimiento básico de los principales conceptos de Docker, como los contenedores, las imágenes de contenedor y los comandos de docker. Para una introducción a los conceptos básicos de los contenedores, consulte Introducción a Docker.

Para completar este tutorial, se necesita un entorno de desarrollo de Docker local en el que se ejecuten contenedores Linux. Docker proporciona paquetes que configuran Docker en un sistema Mac, Windows o Linux.

Obtención del código de la aplicación

La aplicación sample que se usa en este tutorial es una aplicación front-end de la tienda básica, incluidas las siguientes implementaciones y servicios de Kubernetes:

• Tienda virtual: aplicación web en línea para que los clientes vean productos y realicen pedidos.
• Servicio de producto: muestra información del producto.
• Servicio de pedidos: realiza pedidos.
• RabbitMQ: cola de mensajes para una cola de pedidos.

Revisión del archivo de Docker Compose

La aplicación de ejemplo que se crea en este tutorial usa el archivo YAML docker-compose-quickstart del repositorio que ha clonado.

En la tabla siguiente se resumen los valores predeterminados clave del archivo compose de ejemplo para que pueda ver rápidamente qué servicios, puertos y dependencias usa el tutorial:

services:
  rabbitmq:
    image: rabbitmq:4.3.2-management-alpine
    container_name: 'rabbitmq'
    restart: always
    environment:
      - "RABBITMQ_DEFAULT_USER=username"
      - "RABBITMQ_DEFAULT_PASS=password"
    ports:
      - 15672:15672
      - 5672:5672
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  order-service:
    build: src/order-service
    container_name: 'order-service'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://order-service:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - ORDER_QUEUE_HOSTNAME=rabbitmq
      - ORDER_QUEUE_PORT=5672
      - ORDER_QUEUE_USERNAME=username
      - ORDER_QUEUE_PASSWORD=password
      - ORDER_QUEUE_NAME=orders
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  product-service:
    build: src/product-service
    container_name: 'product-service'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://product-service:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - AI_SERVICE_URL=http://ai-service:5001/
    networks:
      - backend_services
  store-front:
    build: src/store-front
    container_name: 'store-front'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://store-front:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://product-service:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://order-service:3000/
    networks:
      - backend_services
    depends_on:
      - product-service
      - order-service
networks:
  backend_services:
    driver: bridge

Creación de imágenes de contenedor y ejecución de la aplicación

Se puede utilizar Docker Compose para automatizar la creación de imágenes de contenedor y la implementación de aplicaciones con varios contenedores.

Asegúrese de que Docker se está ejecutando en modo contenedor de Linux antes de ejecutar los siguientes comandos.

1. Desde la raíz del repositorio clonado aks-store-demo , cree la imagen de contenedor, descargue la imagen rabbitMQ e inicie la aplicación con el docker compose comando :

   docker compose -f docker-compose-quickstart.yml up -d
   

2. Vea las imágenes creadas mediante el comando docker images.

   docker images
   

   En la siguiente salida de ejemplo reducida se muestran las imágenes creadas:

   REPOSITORY                        TAG                          IMAGE ID
   aks-store-demo-product-service    latest                       72f5cd7e6b84
   aks-store-demo-order-service      latest                       54ad5de546f9
   aks-store-demo-store-front        latest                       1125f85632ae
   ...
   

3. Vea los contenedores en ejecución mediante el comando docker ps.

   docker ps
   

   En la salida de ejemplo condensada siguiente se muestran cuatro contenedores en ejecución:

   CONTAINER ID        IMAGE
   f27fe74cfd0a        aks-store-demo-product-service
   df1eaa137885        aks-store-demo-order-service
   b3ce9e496e96        aks-store-demo-store-front
   31df28627ffa        rabbitmq:4.3.2-management-alpine
   

Prueba local de la aplicación

Para ver la aplicación en ejecución, vaya a http://localhost:8080 en un explorador web local. Se carga la aplicación de ejemplo, como se muestra en el ejemplo siguiente:

En esta página, puede ver los productos, agregarlos al carro y, a continuación, realizar un pedido.

Migración de sus propios archivos de Compose

Si ya tiene una aplicación definida en un archivo de Docker Compose, puede usar este tutorial como referencia para la validación local y, a continuación, convertir la configuración de Compose existente en manifiestos de Kubernetes. Use herramientas como Kompose, Move2Kube, Docker Compose Bridge o Podman para convertir definiciones de Docker Compose en recursos de Kubernetes. Para ver el proceso completo de conversión de principio a fin, consulte la documentación de Kubernetes sobre la migración de Docker Compose a Kubernetes y la información general sobre la migración de AKS si también va a migrar desde otro orquestador o flujo de trabajo de modernización.

Elegir una herramienta de conversión

Use esta tabla cuando necesite una comparación rápida de las opciones de Compose-to-Kubernetes más comunes.

¿Qué herramienta debo elegir?

• Si desea una prueba rápida de concepto o manifiestos de inicio, use Kompose.
• Si usa Docker Desktop y quiere una ruta de acceso nativa de Docker, use Docker Compose Bridge.
• Si tiene un mayor esfuerzo de migración o modernización de varios servicios, use Move2Kube.
• Si desea exportar desde contenedores o pods en ejecución, use Podman.
• Si ya tiene manifiestos y necesita empaquetar o superposiciones, use Helm o Kustomize.
• Si necesita un bucle de desarrollo de Kubernetes local después de la conversión, use Skaffold o Tilt.
• Si desea crear borradores de manifiestos o explicaciones de migración, use la asistencia de INTELIGENCIA artificial y valide el resultado con las instrucciones oficiales de Kubernetes y AKS.

Otras herramientas que se deben tener en cuenta:

• 8gwifi.org convertidor YAML de Kubernetes: útil para experimentos rápidos en línea con pequeños archivos compose.
• Okteto: útil cuando desea un bucle de desarrollo remoto o de nube de Kubernetes para los equipos de aplicaciones.
• Devtron: útil cuando se desea un flujo de trabajo de plataforma en torno a la entrega de Kubernetes después de la conversión.
• Portainer: útil cuando se desea una experiencia de administración de Kubernetes y un contenedor controlado por la interfaz de usuario.

Convertir los archivos de Compose

Use los siguientes comandos copiables como punto de partida:

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Ejemplo de conversión de Kompose

La herramienta Kompose de código abierto convierte la configuración común de Docker Compose en objetos de Kubernetes, como implementaciones y servicios.

1. En Windows, instale Kompose con el siguiente comando:

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Para ver otras opciones de instalación, consulte las instrucciones de instalación de Kompose.

2. Ejecute Kompose desde el directorio que contiene el docker-compose.yml archivo.

   kompose convert
   

3. Revise los archivos YAML de Kubernetes generados antes de implementarlos en AKS.

Conversión asistida por IA

Puede usar un asistente de IA para redactar manifiestos de Kubernetes, comparar la configuración de Compose con equivalentes de Kubernetes o explicar por qué una conversión necesita cambios manuales.

Indicador de ejemplo genérico:

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Solicitud de ejemplo dirigida a AKS:

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Revise siempre el resultado de la IA antes de aplicarlo. Valide apiVersion los valores, las solicitudes de recursos y los límites, las clases de almacenamiento, la exposición del servicio y los sondeos de estado.

Control de problemas comunes de traducción

¿Cómo se controlan los volúmenes?

Compose volumes suele necesitar volúmenes persistentes de Kubernetes y una clase de almacenamiento. En AKS, sustituya los montajes exclusivamente locales por servicios como Azure Disks o Azure Files.

¿Qué reemplaza depends_on?

Compose depends_on no impone la disponibilidad en tiempo de ejecución en Kubernetes. Sustitúyalo por sondas de preparación, sondas de arranque o la lógica de un contenedor de inicialización cuando sea necesario.

¿Cómo debo controlar los secretos y los valores de entorno?

Los valores de entorno de Compose suelen convertirse en recursos de Kubernetes ConfigMap o Secret, o en integraciones con Azure Key Vault.

¿Qué ocurre con los puertos y la entrada?

Compose ports se traduce en objetos de Kubernetes Service y, a veces, en recursos de Ingress o de Gateway API, según cómo expongas la aplicación.

¿Cómo se traducen las comprobaciones de estado?

Normalmente, la configuración de Compose healthcheck suele convertirse en sondas de actividad y de preparación de Kubernetes.

¿Qué ocurre con las redes de Compose?

Las redes de Compose suelen traducirse a la detección de servicios de Kubernetes mediante Services y el DNS del clúster, en lugar de redes puente personalizadas.

¿Cómo se prueba localmente con Kubernetes?

Después de la conversión, implemente los manifiestos generados en un entorno de Kubernetes local, como kind o minikube, use Skaffold o Tilt si desea un bucle edit-build-deploy más rápido.

Aplicar ajustes específicos de AKS después de la conversión

Kompose le ofrece un punto de partida, pero normalmente necesita realizar cambios manuales para AKS:

• Actualice las referencias de las imágenes para que apunten a su Azure Container Registry (ACR).
• Reemplace el almacenamiento local y los montajes enlazados por un almacenamiento persistente, como Azure Disks o Azure Files, según las necesidades de su carga de trabajo.
• Reemplazar los secretos de Compose o los valores específicos del entorno por Secrets de Kubernetes, ConfigMaps o integraciones con Azure Key Vault.
• Revise la configuración de red y de exposición, como LoadBalancer, ingress o la configuración de la puerta de enlace, en función de cómo desee publicar la aplicación en AKS.
• Compruebe si los componentes con estado deben permanecer como Implementaciones o pasar a patrones como StatefulSets cuando necesite un comportamiento estable de identidad o almacenamiento.
• Valide las solicitudes de recursos, los sondeos y las suposiciones de ordenación de inicio porque los comportamientos de Compose, como depends_on no se traducen directamente en el comportamiento en tiempo de ejecución de Kubernetes.

Flujo de trabajo posterior a la conversión

1. Convierta el archivo Compose con una herramienta como Kompose, Move2Kube, Docker Compose Bridge, Podman o un borrador revisado por IA.
2. Revise y refuerce los manifiestos corrigiendo el almacenamiento, los secretos, la exposición de servicios, las sondas y las referencias de imágenes.
3. Empaquete los manifiestos con Helm o aplique cambios específicos del entorno con Kustomize.
4. Publique las imágenes en un registro, como ACR, y luego implemente mediante GitOps, CI/CD o flujos de trabajo directos kubectl.

Secuencia de ejemplo: kompose convert -> revisar manifiestos :> insertar imágenes en ACR -> actualizar referencias de imagen ->kubectl apply o helm install.

Limpieza de recursos

Si ha seguido el flujo de trabajo de Docker Compose, puede detener y quitar los contenedores en ejecución. No elimine las imágenes de contenedor porque las usa en el siguiente tutorial. Si ha seguido el flujo de trabajo de la CLI para desarrolladores de Azure, use azd down en lugar de docker compose down.

Para detener y quitar las instancias de contenedor y los recursos, use el comando docker compose down.

docker compose down

Comandos de la CLI de Azure Developer

Cuando se usa azd, no hay dependencias manuales de imágenes de contenedor. azd controla el aprovisionamiento, la implementación y limpia las aplicaciones y los clústeres con los comandos azd up y azd down, de forma similar a Docker.

Puede personalizar los pasos de preparación para usar Terraform o Bicep antes de implementar el clúster en la sección infra de su azure.yaml. De forma predeterminada, este proyecto usa Terraform:

infra:
  provider: terraform
  path: infra/terraform

Si desea cambiar el proveedor a Bicep, actualice el archivo azure.yaml de la siguiente manera:

infra:
  provider: bicep
  path: infra/bicep

Pasos siguientes

CLI de Azure

En este tutorial, ha creado una aplicación de ejemplo e imágenes de contenedor para la aplicación y, después, ha probado la aplicación. Ha aprendido a:

En el siguiente tutorial, aprenderá cómo almacenar imágenes de contenedor en un ACR.

CLI para desarrolladores de Azure

En este tutorial, ha clonado una aplicación de ejemplo mediante azd. Ha aprendido a:

En el siguiente tutorial, aprenderá a crear un clúster mediante la plantilla azd que ha clonado.