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

Empiece a trabajar con Azure Container Linux (ACL) para AKS mediante la implementación de un clúster de AKS mediante una plantilla de Azure Resource Manager (ARM).

En este inicio rápido, aprenderá a:

  • Cree un clúster de AKS mediante ACL para AKS.
  • Implemente el clúster con una plantilla de ARM.
  • Ejecute una aplicación de muestra de varios contenedores con un grupo de microservicios e interfaces web simulando un escenario de venta minorista.

Note

Para empezar a aprovisionar rápidamente un clúster de AKS, 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 de base para considerar 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:

Prerrequisitos

  • En este artículo 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.
  • Asegúrese de que la identidad que usa para crear el clúster tiene 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).
  • Para implementar una plantilla de ARM, necesita acceso de escritura en los recursos que va a implementar y acceder a todas las operaciones del tipo de recurso Microsoft.Resources/deployments. Por ejemplo, para implementar una máquina virtual, necesita permisos Microsoft.Compute/virtualMachines/write y Microsoft.Resources/deployments/*. Para obtener una lista de roles y permisos, consulte Roles integrados de Azure.

Después de implementar el clúster desde la plantilla, puede usar la CLI de Azure o Azure PowerShell para conectarse al clúster e implementar la aplicación de ejemplo.

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

Creación de un par de claves SSH

Para crear un clúster de AKS con una plantilla de ARM, debe proporcionar una clave pública SSH. Si necesita este recurso, siga los pasos de esta sección. De lo contrario, vaya a la sección Revisar la plantilla.

Para acceder a los nodos de AKS, se conectará mediante un par de claves SSH (pública y privada), que se genera mediante el comando ssh-keygen. De forma predeterminada, estos archivos se crean en el directorio ~/.ssh. La ejecución del comando ssh-keygen sobrescribe cualquier par de claves SSH con el mismo nombre que ya exista en la ubicación especificada. Para más información sobre cómo crear claves SSH, consulte el artículo sobre Creación y administración de claves SSH para la autenticación en Azure.

  1. Vaya a https://shell.azure.com para abrir Cloud Shell en el explorador.

  2. Cree un grupo de recursos con el comando az group create. En el ejemplo siguiente se crea un grupo de recursos denominado myResourceGroup en la región Este de EE. UU .:

    az group create \
  --name myResourceGroup \
  --location eastus

  3. Cree un par de claves SSH mediante el az sshkey create comando o el ssh-keygen comando .

    az sshkey create --name mySSHKey --resource-group myResourceGroup

    O bien, cree un par de claves SSH mediante ssh-keygen:

    ssh-keygen -t rsa -b 4096

  4. Para implementar la plantilla, debe proporcionar la clave pública del par SSH. Recupere la clave pública mediante el az sshkey show comando .

    az sshkey show --name mySSHKey --resource-group myResourceGroup --query publicKey

Revisión de la plantilla

La siguiente implementación usa una plantilla de ARM de Azure Plantillas de inicio rápido:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.26.170.59819",
      "templateHash": "14823542069333410776"
    }
  },
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aks101cluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "minValue": 0,
      "maxValue": 1023,
      "metadata": {
        "description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "minValue": 1,
      "maxValue": 50,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2026-03-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "osSKU": "AzureContainerLinux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2026-03-01').fqdn]"
    }
  }
}

El tipo de recurso definido en la plantilla de ARM es Microsoft.ContainerService/managedClusters.

Para más ejemplos de AKS, consulte el sitio de plantillas de inicio rápido de AKS.

Implementación de la plantilla

  1. Seleccione Implementar en Azure para iniciar sesión y abrir una plantilla.

    Botón para implementar la plantilla de Resource Manager en Azure.

  2. Configure los parámetros de plantilla en la página Implementación personalizada . En este inicio rápido, deje los valores predeterminados para el tamaño de disco del sistema operativo GB, el recuento de agentes, el tamaño de máquina virtual del agente y el tipo de sistema operativo. Proporcione sus propios valores para los parámetros siguientes:

    • Suscripción: Seleccione una suscripción de Azure.
    • Grupo de recursos: Seleccione Crear nuevo. Escriba un nombre único para el grupo de recursos, como myResourceGroup, y seleccione Aceptar.
    • SKU del sistema operativo: especifique AzureContainerLinux. Si no actualiza la SKU del sistema operativo, el valor predeterminado es Ubuntu.
    • Ubicación: seleccione una ubicación, como Este de EE. UU.
    • Nombre del clúster: escriba un nombre único para el clúster de AKS, como myAKSCluster.
    • Prefijo de DNS: escriba un prefijo DNS único para el clúster, como myakscluster.
    • Linux Admin Username (Nombre de usuario administrador de Linux): escriba un nombre de usuario para conectarse mediante SSH, como azureuser.
    • Origen de la clave pública SSH: seleccione Usar clave pública existente.
    • Nombre del par de claves: copie y pegue la parte pública del par de claves SSH (de forma predeterminada, el contenido de ~/.ssh/id_rsa.pub).

  3. Seleccione Revisar y crear>Crear.

El clúster de AKS tarda unos minutos en crearse. Espere a que el clúster se implemente correctamente para pasar al siguiente paso.

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. Si usa Azure Cloud Shell, kubectl ya está instalado.

Para instalar y ejecutar kubectl localmente, use el az aks install-cli comando .

  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 myResourceGroup \
  --name myAKSCluster

  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

    La salida del siguiente ejemplo muestra los tres nodos creados en los pasos anteriores. Asegúrese de que el estado del nodo es Listo:

    NAME                                STATUS   ROLES   AGE   VERSION
aks-agentpool-12345678-vmss000000   Ready    <none>   5m53s   v1.32.7
aks-agentpool-12345678-vmss000001   Ready    <none>   6m31s   v1.32.7
aks-agentpool-12345678-vmss000002   Ready    <none>   6m35s   v1.32.7

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:

Captura de pantalla de la arquitectura de ejemplo de Azure Store.

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

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

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq
spec:
  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
      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
        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

    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, para cargar el archivo de manifiesto en el directorio predeterminado de CloudShell, seleccione el botón Cargar y descargar archivos y elija el archivo en el 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

  1. Compruebe el estado de los pods implementados con el comando kubectl get pods. Antes de continuar, haz que todos los pods tengan el estado Running.

    kubectl get pods

  2. Comprueba si la aplicación de tienda tiene una dirección IP pública. 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

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

  4. Abra un explorador web en la dirección IP externa del servicio para ver la aplicación de la Tienda Azure en acción:

    Captura de pantalla de la aplicación de ejemplo de almacén de AKS.

Eliminación del clúster

Si no planea pasar por el tutorial AKS, elimine los recursos innecesarios para evitar cargos en 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 myResourceGroup --yes --no-wait

Note

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 una plantilla de ARM. Para más información sobre ACL para AKS, consulte Azure Container Linux (ACL) para Azure Kubernetes Service (AKS).

  • Last updated on