Inicio rápido: Implementación de una Azure Container Linux (ACL) para el clúster de AKS mediante CLI de Azure

Empiece a trabajar con Azure Container Linux (ACL) para AKS mediante la implementación de un clúster de AKS mediante el CLI de Azure.

En este inicio rápido, aprenderá a:

• Cree un clúster de AKS mediante ACL para AKS.
• Implemente el clúster mediante CLI de Azure.
• Ejecute una aplicación de varios contenedores de ejemplo con un grupo de microservicios y front-end web que simulan un escenario comercial.

Note

En este artículo se incluyen los pasos para implementar un clúster con la configuración predeterminada solo con fines de evaluación. Antes de implementar un clúster listo para producción, se recomienda familiarizarse con nuestra arquitectura de referencia de línea base para tener en cuenta cómo se alinea con sus requisitos empresariales.

Importante

Si usa Azure Container Linux (ACL) en AKS, asegúrese de revisar las siguientes consideraciones y limitaciones:

• La ACL está disponible con carácter general a partir de AKS v1.34.
• La ACL requiere inicio seguro con arranque seguro y vTPM. Las variantes de arranque no fiables no están disponibles.
• ACL en Arm64 requiere SKU basados en Cobalt (v6) para habilitar la compatibilidad con Trusted Launch.
• NodeImage y None son los únicos canales de actualización del sistema operativo (SO) admitidos. Unmanaged y SecurityPatch son incompatibles con la ACL debido al directorio inmutable /usr .
• El streaming de artefactos no se admite.
• No se admite el sandboxing de pods.
• No se admiten máquinas virtuales confidenciales (CVM).
• No se admiten máquinas virtuales de generación 1.
• No se admiten nodos habilitados para FIPS.

Prerrequisitos

• En esta guía rápida se presupone un conocimiento básico de los conceptos de Kubernetes. Para más información, consulte Conceptos básicos de Kubernetes de Azure Kubernetes Service (AKS).

• Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

• Use el entorno de Bash en Azure Cloud Shell. Para obtener más información, consulte Introducción a Azure Cloud Shell.

• Si prefiere ejecutar comandos de referencia de la CLI localmente, instale el CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar CLI de Azure en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el CLI de Azure en un contenedor de Docker.

  • Si usa una instalación local, inicie sesión en el CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Autenticación en Azure mediante la CLI de Azure.
  • Cuando se le solicite, instale la extensión CLI de Azure en el primer uso. Para obtener más información sobre las extensiones, consulte Uso y administración de extensiones con la CLI de Azure.
  • Necesita CLI de Azure versión 2.86.0 o posterior. Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

• Asegúrese de que la identidad que usará para crear el clúster tenga los permisos mínimos adecuados. Para más información sobre el acceso y la identidad en AKS, consulte Opciones de acceso e identidad en Azure Kubernetes Service (AKS).

• Si tiene varias suscripciones de Azure, seleccione el identificador de suscripción adecuado en el que se deben facturar los recursos mediante el comando az account set. Para más información, consulte Cómo administrar suscripciones de Azure: CLI de Azure.

• En función de la suscripción de Azure, es posible que tenga que solicitar un aumento de cuota de vCPU. Para más información, consulte Aumento de las cuotas de vCPU de la familia de máquinas virtuales.

Registro de los proveedores de recursos necesarios

Es posible que tenga que registrar los proveedores de recursos necesarios, como Microsoft.ContainerService en la suscripción de Azure.

Comprobación del estado del registro

Compruebe el estado del registro mediante el az provider show comando .

az provider show --namespace Microsoft.ContainerService --query registrationState

Registrar el proveedor de recursos

Si es necesario, registre el proveedor de recursos Microsoft.ContainerService mediante el comando az provider register.

az provider register --namespace Microsoft.ContainerService

Definición de variables de entorno

Defina las siguientes variables de entorno para usarlas en este inicio rápido. Puede reemplazar los valores por sus propios nombres personalizados si lo prefiere.

export RESOURCE_GROUP="myAKSResourceGroup"
export REGION="westus"
export CLUSTER_NAME="myAKSCluster"

Creación de un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Cuando crea un grupo de recursos, se le pide que especifique una ubicación. Esta ubicación es la ubicación de almacenamiento de los metadatos del grupo de recursos y donde se ejecutan los recursos en Azure si no se especifica otra región durante la creación de recursos.

Cree un grupo de recursos con el comando az group create.

az group create \
  --name $RESOURCE_GROUP \
  --location $REGION

Ejemplo de resultado:

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Creación de un clúster de AKS

Cree un clúster de AKS con el comando az aks create. El --os-sku AzureContainerLinux parámetro configura el grupo de nodos del sistema para que use ACL como sistema operativo del nodo. En el ejemplo siguiente se crea un clúster con un nodo y se habilita una identidad administrada asignada por el sistema:

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 1 \
  --generate-ssh-keys

Note

Al crear un nuevo clúster, AKS crea automáticamente un segundo grupo de recursos para almacenar los recursos de AKS. Para más información, consulte ¿Por qué se crean dos grupos de recursos con AKS?

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. kubectl ya está instalado si usa Azure Cloud Shell. Para instalar kubectl localmente, use el comando az aks install-cli.

1. Para configurar kubectl para conectarse a su clúster de Kubernetes, use el comando az aks get-credentials. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

   az aks get-credentials \
     --resource-group $RESOURCE_GROUP \
     --name $CLUSTER_NAME
   

2. Compruebe la conexión al clúster con el comando kubectl get. Este comando devuelve una lista de los nodos del clúster.

   kubectl get nodes
   

Implementación de la aplicación

Para implementar la aplicación, se usa un archivo de manifiesto para crear todos los objetos necesarios para ejecutar la aplicación AKS Store. Un archivo de manifiesto de Kubernetes define el estado deseado de un clúster, como las imágenes de contenedor que se van a ejecutar. El manifiesto incluye las siguientes implementaciones y servicios de Kubernetes:

• Tienda virtual: 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.
• RabbitMQ: cola de mensajes para una cola de pedidos.

Note

No se recomienda ejecutar contenedores con estado, como RabbitMQ, sin almacenamiento persistente para producción. Lo usamos aquí para simplificar, pero se recomienda usar servicios administrados, como Azure Cosmos DB o Azure Service Bus.

1. Cree un archivo denominado aks-store-quickstart.yaml y copie en el siguiente manifiesto:

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: rabbitmq
   spec:
     serviceName: rabbitmq
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
           startupProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 20
             periodSeconds: 10
           readinessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           env:
           - name: AI_SERVICE_URL
             value: "http://ai-service:5001/"
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 2m
               memory: 20Mi
           readinessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env:
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
           startupProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 3
           livenessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Para obtener un desglose de los archivos de manifiesto de YAML, consulte Implementaciones y manifiestos de YAML.

   Si crea y guarda el archivo YAML localmente, puede cargar el archivo de manifiesto en el directorio predeterminado de Cloud Shell seleccionando el botón Cargar y descargar archivos y seleccionando el archivo del sistema de archivos local.

2. Implemente la aplicación mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML.

   kubectl apply -f aks-store-quickstart.yaml
   

   La salida del siguiente ejemplo muestra las implementaciones y los servicios creados correctamente:

   deployment.apps/rabbitmq created
   service/rabbitmq created
   deployment.apps/order-service created
   service/order-service created
   deployment.apps/product-service created
   service/product-service created
   deployment.apps/store-front created
   service/store-front created
   

Prueba de la aplicación

Cuando se ejecuta la aplicación, un servicio de Kubernetes expone el front-end de la aplicación a Internet. Este proceso puede tardar unos minutos en completarse.

1. Compruebe el estado de los pods implementados con el comando kubectl get pods. Asegúrate de que todos los pods tengan el estado Running antes de continuar.

   kubectl get pods
   

2. Compruebe si hay una dirección IP pública para la aplicación store-front. Para supervisar el progreso, utilice el comando kubectl get service con el argumento --watch.

   kubectl get service store-front --watch
   

   La salida de EXTERNAL-IP del servicio store-front aparece inicialmente como pending (pendiente):

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
   

   Una vez que la dirección EXTERNAL-IP cambia de pendiente a una dirección IP pública real, use CTRL-C para detener el kubectl proceso de inspección.

   En la salida del ejemplo siguiente se muestra una dirección IP pública válida asignada al servicio:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
   

3. Abra un explorador web en la dirección IP externa del servicio para ver la aplicación Azure Store en acción.

   

Eliminación del clúster

Si no planea pasar por el tutorial de AKS, limpie los recursos innecesarios para evitar cargos de facturación de Azure.

Quite el grupo de recursos, el servicio de contenedor y todos los recursos relacionados mediante el comando az group delete.

az group delete --name $RESOURCE_GROUP

El clúster de AKS se creó con una identidad administrada asignada por el sistema, que es la opción de identidad predeterminada utilizada en este inicio rápido. La plataforma administra esta identidad para que no tenga que quitarla manualmente.

Contenido relacionado

En este inicio rápido, ha implementado un clúster de AKS con ACL para AKS mediante CLI de Azure. Para más información sobre ACL para AKS, consulte Azure Container Linux (ACL) para Azure Kubernetes Service (AKS).