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

En este tutorial, la primera parte de siete, se prepara una aplicación con varios contenedores para usarla en Kubernetes. Puede usar herramientas de desarrollo existentes, como Docker Compose, para compilar y probar la aplicación localmente. Aprenderá a:

  • Clonar el origen de una aplicación de ejemplo desde GitHub.
  • Crear una imagen de contenedor a partir del origen de la aplicación de ejemplo.
  • Probar la aplicación con varios contenedores en un entorno local de Docker.

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

Screenshot showing the Azure Store Front App running locally opened in a local web browser.

En tutoriales posteriores, la imagen de contenedor se carga en una instancia de Azure Container Registry (ACR) y después se implementa 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. Si es necesario, consulte la introducción a Docker, donde encontrará datos básicos acerca de los contenedores.

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

Nota:

Azure Cloud Shell no incluye los componentes de Docker necesarios para completar todos los pasos de este tutorial. Por lo tanto, se recomienda usar un entorno completo de desarrollo de Docker.

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

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

Screenshot of Azure Store sample architecture.

  • Escaparate: aplicación web para que los clientes vean productos y realicen pedidos.
  • Servicio de producto: muestra información del producto.
  • Servicio de pedidos: realiza pedidos.
  • Rabbit MQ: cola de mensajes para una cola de pedidos.
  1. Use git para clonar la aplicación en su entorno de desarrollo.

    git clone https://github.com/Azure-Samples/aks-store-demo.git
    
  2. Cambie al directorio clonado.

    cd aks-store-demo
    

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 en el repositorio que ha clonado en el paso anterior.

version: "3.7"
services:
  rabbitmq:
    image: rabbitmq:3.11.17-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
    volumes:
      - ./rabbitmq_enabled_plugins:/etc/rabbitmq/enabled_plugins
    networks:
      - backend_services
  orderservice:
    build: src/order-service
    container_name: 'orderservice'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://orderservice: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
      - ORDER_QUEUE_RECONNECT_LIMIT=3
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  productservice:
    build: src/product-service
    container_name: 'productservice'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://productservice:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  storefront:
    build: src/store-front
    container_name: 'storefront'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://storefront:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://productservice:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://orderservice:3000/
    networks:
      - backend_services
    depends_on:
      - productservice
      - orderservice
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.

  1. Cree la imagen de contenedor, descargue la imagen de Redis e inicie la aplicación mediante el comando docker compose.

    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-productservice    latest                       2b66a7e91eca
    aks-store-demo-orderservice      latest                       54ad5de546f9
    aks-store-demo-storefront        latest                       d9e3ac46a225
    rabbitmq                         3.11.17-management-alpine    79a570297657
    ...
    
  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
    21574cb38c1f        aks-store-demo-productservice
    c30a5ed8d86a        aks-store-demo-orderservice
    d10e5244f237        aks-store-demo-storefront
    94e00b50b86a        rabbitmq:3.11.17-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:

Screenshot showing the Azure Store Front App opened in a local browser.

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

Limpieza de recursos

Puesto que validó la funcionalidad de la aplicación, puede detener y quitar los contenedores en ejecución. No elimine las imágenes de contenedor: las usará en el siguiente tutorial.

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

    docker compose down
    

Pasos siguientes

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:

  • Clonar el origen de una aplicación de ejemplo desde GitHub.
  • Crear una imagen de contenedor a partir del origen de la aplicación de ejemplo.
  • Probar la aplicación con varios contenedores en un entorno local de Docker.

En el tutorial siguiente, descubrirá cómo almacenar imágenes de contenedor en una instancia de ACR.