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

En este inicio rápido, usará el CLI de Azure para crear un clúster de Azure Kubernetes Service (AKS) que ejecute Azure Container Linux (ACL) como sistema operativo del nodo. Después de implementar el clúster, conéctese a él mediante kubectl y compruebe que los nodos de ACL se ejecutan según lo previsto.

Consideraciones y limitaciones

Antes de comenzar, revise las siguientes consideraciones y limitaciones para ACL:

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 que no son de Inicio seguro 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 admitidos. Unmanaged y SecurityPatch son incompatibles con la ACL debido al directorio inmutable /usr .
No se admite el streaming de artefactos.
No se admite el espacio aislado de pods.
No se admiten máquinas virtuales confidenciales (CVM).
No se admiten máquinas virtuales de generación 1.

Prerrequisitos

Note

Puede usar Azure Cloud Shell o una instalación local del CLI de Azure para ejecutar los comandos en este inicio rápido.

Si ejecuta el CLI de Azure 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 otras opciones de inicio de sesión, consulta Iniciar sesión con CLI de Azure.
En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.
Use el comando az version para buscar la versión de CLI de Azure y las bibliotecas dependientes que están instaladas. Azure Container Linux requiere CLI de Azure versión 2.86.0 o posterior. Para actualizar a la versión más reciente, use el az upgrade comando .
Si es necesario, registre el proveedor de recursos Microsoft.ContainerService en su suscripción a Azure.

Registrar el proveedor de recursos Microsoft.ContainerService

Es posible que tenga que registrar proveedores de recursos en la suscripción de Azure. Compruebe el estado del registro mediante el az provider show comando .

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

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

az provider register --namespace Microsoft.ContainerService

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 los recursos de Azure. Cuando se crea un grupo de recursos, necesita especificar una ubicación. Esta ubicación es:

Ubicación de almacenamiento de los metadatos del grupo de recursos.
El lugar en el que se ejecutan los recursos en Azure si no se especifica otra región al crearlos.

Cree un grupo de recursos con el comando az group create. En el ejemplo siguiente se establecen variables de entorno para el nombre del grupo de recursos, la región y el nombre del clúster de AKS y, a continuación, se crea un grupo de recursos en la ubicación especificada. Puede reemplazar los valores de las variables de entorno por sus propios nombres y regiones preferidos.

export MY_RESOURCE_GROUP_NAME="myACLResourceGroup"
export REGION="westus"
export MY_AKS_CLUSTER_NAME="myACLCluster"

az group create --name $MY_RESOURCE_GROUP_NAME --location $REGION

Ejemplo de resultado:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myACLResourceGroup",
  "location": "westus",
  "managedBy": null,
  "name": "myACLResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Creación de un clúster de ACL

Cree un clúster de AKS mediante el az aks create comando con el --os-sku AzureContainerLinux parámetro para aprovisionar el clúster de AKS con una imagen de ACL.

az aks create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_AKS_CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 3 \
  --generate-ssh-keys

Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Conectarse al clúster

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

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 $MY_RESOURCE_GROUP_NAME --name $MY_AKS_CLUSTER_NAME
```
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 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.
Rabbit MQ: cola de mensajes utilizada para gestionar pedidos.

Note

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

Cree un archivo denominado aks-store-quickstart.yaml y cópielo 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
---
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
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
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
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

Implemente la aplicación mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML.
```
kubectl apply -f aks-store-quickstart.yaml
```

Prueba de la aplicación

Puede validar que la aplicación se está ejecutando visitando la dirección IP pública o la dirección URL de la aplicación.

Obtenga la dirección URL de la aplicación mediante los siguientes comandos:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo "Status: $STATUS"
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done

echo "http://$IP_ADDRESS"

Eliminación del clúster

Si no piensas seguir los tutoriales, elimina los recursos innecesarios para evitar cargos 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 $MY_RESOURCE_GROUP_NAME --yes --no-wait

Para obtener más información sobre ACL para AKS, consulte ¿Qué es Azure Container Linux (ACL) para Azure Kubernetes Service (AKS)?

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-06-03