Guida introduttiva: Distribuire un cluster di Servizio Azure Kubernetes (AKS) con Azure Container Linux (ACL) usando un modello ARM

In questa guida introduttiva si usa un modello di Azure Resource Manager (ARM) per creare un cluster Servizio Azure Kubernetes (AKS) che esegue Azure Contenitore Linux (ACL) come sistema operativo del nodo. Dopo aver installato i prerequisiti, creare una coppia di chiavi SSH, esaminare il modello, distribuire il modello e connettersi al cluster.

considerazioni e limitazioni di Azure Container Linux (ACL)

Prima di iniziare, esamina le seguenti considerazioni e limitazioni per ACL:

Prerequisiti

Annotazioni

È possibile usare Azure Cloud Shell o un'installazione locale del interfaccia della riga di comando di Azure per eseguire i comandi in questa guida introduttiva.

  • Se si esegue l'interfaccia della riga di comando di Azure in locale, installare l'interfaccia della riga di comando di Azure. Se si esegue in Windows o macOS, è consigliabile eseguire interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire il interfaccia della riga di comando di Azure in un contenitore Docker.
  • Se si usa un'installazione locale, accedere al interfaccia della riga di comando di Azure usando il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere con il interfaccia della riga di comando di Azure.
  • Se richiesto, installare l'estensione di interfaccia della riga di comando di Azure al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare le estensioni con l'interfaccia della riga di comando di Azure.
  • Azure Container Linux richiede interfaccia della riga di comando di Azure versione 2.86.0 o successiva. Usare il comando az version per trovare la versione interfaccia della riga di comando di Azure e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, usare il az upgrade comando .
  • Se kubectl non è già installato, installarlo tramite interfaccia della riga di comando di Azure usando il comando az aks install-cli o seguire le istruzioni upstream.
  • Per creare un cluster AKS usando un modello ARM, è necessario fornire una chiave pubblica SSH. Se è necessaria questa risorsa, passare alla sezione Creare una coppia di chiavi SSH per generarne una prima di distribuire il modello. Se si dispone già di una coppia di chiavi SSH, è possibile passare alla sezione Esaminare il modello .
  • L'identità usata per creare il cluster deve avere le autorizzazioni minime appropriate. Per altre informazioni sull'accesso e l'identità per il servizio Azure Kubernetes, vedere Opzioni di accesso e identità per il servizio Azure Kubernetes.
  • Per distribuire un modello ARM, è necessario disporre dell'accesso in scrittura alle risorse che si stanno distribuendo e dell'accesso a tutte le operazioni sul tipo di risorsa Microsoft.Resources/deployments. Ad esempio, per distribuire una macchina virtuale (VM), sono necessarie le autorizzazioni Microsoft.Compute/virtualMachines/write e Microsoft.Resources/deployments/*. Per un elenco dei ruoli e delle autorizzazioni, vedere Ruoli predefiniti di Azure.

Creare una coppia di chiavi SSH

Per accedere ai nodi di AKS, ci si connette utilizzando una coppia di chiavi SSH (pubblica e privata) che si genera usando il comando ssh-keygen. Per impostazione predefinita, questi file vengono creati nella directory ~/.ssh. L'esecuzione del comando ssh-keygen sovrascrive qualsiasi coppia di chiavi SSH con lo stesso nome già esistente nella posizione specificata.

  1. Passare a https://shell.azure.com per aprire Cloud Shell nel browser.

  2. Eseguire il comando ssh-keygen. L'esempio seguente crea una coppia di chiavi SSH usando la crittografia RSA e una lunghezza in bit pari a 4096:

    ssh-keygen -t rsa -b 4096

Per altre informazioni su come creare le chiavi SSH, vedere Creare e gestire chiavi SSH per l'autenticazione in una macchina virtuale Linux in Azure.

Rivedere il modello

La distribuzione seguente usa un modello arm da Azure Modelli di avvio rapido:

{
  "$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]"
    }
  }
}

Il tipo di risorsa definita nel modello di Resource Manager è Microsoft.ContainerService/managedClusters.

Implementare il modello

  1. Selezionare Distribuisci in Azure per accedere e aprire il modello.

    Button per distribuire il modello di Resource Manager in Azure.

  2. Nella pagina Informazioni di base, lasciare i valori predefiniti per GB delle dimensioni disco del sistema operativo, Numero di agenti, dimensione macchina virtuale agente e tipo di sistema operativo, nonché configurare i parametri del modello seguenti:

    • Sottoscrizione: selezionare una sottoscrizione di Azure.
    • Gruppo di risorse: selezionare Crea nuovo. Immettere un nome univoco per il gruppo di risorse, ad esempio myACLResourceGroup, quindi selezionare OK.
    • SKU del sistema operativo: specificare AzureContainerLinux.
    • Località: selezionare una località, ad esempio Stati Uniti occidentali.
    • Nome cluster: Immettere un nome univoco per il cluster AKS, ad esempio myACLCluster.
    • Prefisso DNS: immettere un prefisso DNS univoco per il cluster, ad esempio myaclcluster.
    • Nome utente amministratore Linux: immettere un nome utente per connettersi tramite SSH, ad esempio azureuser.
    • Origine chiave pubblica SSH: selezionare Usa chiave pubblica esistente.
    • Nome della coppia di chiavi: copiare e incollare la parte pubblica della coppia di chiavi SSH (per impostazione predefinita, il contenuto di ~/.ssh/id_rsa.pub).

  3. Selezionare Rivedi e crea>Crea.

    La creazione del cluster del servizio Azure Kubernetes richiede alcuni minuti. Attendere il completamento della distribuzione prima di connettersi al cluster.

Connettersi al cluster

Per gestire un cluster Kubernetes, usare il client da riga di comando kubernetes kubectl. kubectl è già installato se si usa Azure Cloud Shell. Per installare kubectl in locale, usare il comando az aks install-cli.

  1. Configurare kubectl per connettersi al cluster Kubernetes usando il comando az aks get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

    az aks get-credentials --resource-group myACLResourceGroup --name myACLCluster

  2. Verificare la connessione al cluster usando il comando kubectl get. Questo comando restituisce un elenco dei nodi del cluster.

    kubectl get nodes

    L'output di esempio seguente mostra i tre nodi creati nei passaggi precedenti. Assicurarsi che lo stato del nodo sia Pronto:

    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

Eliminare il cluster

Se non hai più bisogno delle risorse create in questa guida introduttiva, puoi eliminarle per evitare addebiti di Azure.

Eliminare il gruppo di risorse Azure e tutte le risorse correlate usando il comando az group delete:

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

Contenuti correlati

In questa guida di avvio rapido è stato distribuito un cluster del servizio Azure Kubernetes per Linux nel contenitore di Azure usando un modello ARM. Per altre informazioni sull'ACL, vedere le risorse seguenti:

  • Last updated on