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

En este inicio rápido, usará una plantilla de Azure Resource Manager (ARM) para crear un clúster de Azure Kubernetes Service (AKS) que usa Azure Container Linux (ACL) como sistema operativo de los nodos. Después de instalar los requisitos previos, cree un par de claves SSH, revise la plantilla, implemente la plantilla y conéctese al clúster.

consideraciones y limitaciones de Azure Container Linux (ACL)

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

• 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.
• Azure Container Linux requiere CLI de Azure versión 2.86.0 o posterior. Use el comando az version para buscar la versión de CLI de Azure y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, use el az upgrade comando .
• Si aún no tiene kubectl instalado, instálelo a través de CLI de Azure mediante el comando az aks install-cli o siga las instrucciones de upstream.
• Para crear un clúster de AKS mediante una plantilla de ARM, debe proporcionar una clave pública SSH. Si necesita este recurso, vaya a la sección Creación de un par de claves SSH para generar uno antes de implementar la plantilla. Si ya tiene un par de claves SSH, puede ir directamente a la sección Revisar la plantilla .
• La identidad que usa para crear el clúster debe tener 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 permisos de escritura sobre los recursos que va a implementar y acceso a todas las operaciones del tipo de recurso Microsoft.Resources/deployments. Por ejemplo, para implementar una máquina virtual (VM), necesita Microsoft. Compute/virtualMachines/write y Microsoft. Recursos/implementaciones/* permisos. Para obtener una lista de roles y permisos, consulte Roles integrados de Azure.

Creación de un par de claves SSH

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.

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

2. Ejecute el comando ssh-keygen. En el ejemplo siguiente se crea un par de claves SSH con cifrado RSA y una longitud en bits de 4096:

   ssh-keygen -t rsa -b 4096
   

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.

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",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aclakscluster",
      "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. Specifying 0 applies 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."
      }
    }
  },
  "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')), '2024-02-01').fqdn]"
    }
  }
}

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

Implementación de la plantilla

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

   

2. En la página Aspectos básicos, deje los valores predeterminados de Tamaño del disco del SO (GB), Número de agentes, Tamaño de VM del agente y Tipo de SO y configure los siguientes parámetros de plantilla:

   • Suscripción: Seleccione una suscripción de Azure.
   • Grupo de recursos: Seleccione Crear nuevo. Escriba un nombre único para el grupo de recursos, como myACLResourceGroup y, a continuación, seleccione Aceptar.
   • SKU del sistema operativo: especifique AzureContainerLinux.
   • Ubicación: seleccione una ubicación, como Oeste de EE. UU.
   • Nombre del clúster: escriba un nombre único para el clúster de AKS, como myACLCluster.
   • Prefijo DNS: escriba un prefijo DNS único para el clúster, como myaclcluster.
   • 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 se complete la implementación antes de conectarse al clúster.

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 myACLResourceGroup --name myACLCluster
   

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-0   Ready    agent   6m44s   v1.34.0
   aks-agentpool-12345678-1   Ready    agent   6m46s   v1.34.0
   aks-agentpool-12345678-2   Ready    agent   6m45s   v1.34.0
   

Eliminación del clúster

Si ya no necesita los recursos que creó en este inicio rápido, puede eliminarlos para evitar cargos de Azure.

Elimine el grupo de recursos Azure y todos los recursos relacionados mediante el comando />

az group delete --name myACLResourceGroup --yes --no-wait

Contenido relacionado

En esta guía de inicio rápido, usted ha implementado un clúster de AKS de Azure Container Linux (ACL) mediante una plantilla de ARM. Para más información sobre la ACL, consulte los siguientes recursos:

• ¿Qué es Azure Container Linux (ACL) para Azure Kubernetes Service (AKS)?