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

Artículo
03/05/2024

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:

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:

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.

Git
CLI de desarrollo de Azure

Use git para clonar la aplicación en su entorno de desarrollo.

git clone https://github.com/Azure-Samples/aks-store-demo.git

Cambie al directorio clonado.
```
cd aks-store-demo
```

Si usa azd localmente, cree un directorio vacío denominado aks-store-demo para hospedar los archivos de plantilla azd.
```
mkdir aks-store-demo
```
Cambie al nuevo directorio para cargar todos los archivos de la plantilla azd.
```
cd aks-store-demo
```
Clone la aplicación de ejemplo en el directorio aks-store-demo mediante el comando [azd init][azd-init] con la marca --template establecida en aks-store-demo.
```
azd init --template 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.

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

Docker
CLI de desarrollo de Azure

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

Docker

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
```

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
...

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:

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
```

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 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

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.

Insertar imágenes en Azure Container Registry