Guida introduttiva: distribuire Azure Container Linux (ACL) per un cluster AKS usando un modello ARM

Per iniziare a usare Azure Container Linux (ACL) per il servizio Azure Kubernetes, distribuire un cluster del servizio Azure Kubernetes usando un modello Azure Resource Manager (ARM).

In questa guida introduttiva si apprenderà come:

Prerequisiti

• Questo articolo presuppone una conoscenza di base dei concetti relativi a Kubernetes. Per altre informazioni, vedere Concetti di base relativi a Kubernetes per il servizio Azure Kubernetes.
• Se non si ha un account Azure, creare un account gratuito prima di iniziare.
• Assicurarsi che l'identità usata per creare il cluster disponga delle autorizzazioni minime appropriate. Per maggiori informazioni sull'accesso e l'identità per il servizio Azure Kubernetes, vedere Opzioni di accesso e identità per il servizio Azure Kubernetes (AKS).
• Per distribuire un modello di Resource Manager, è necessario l'accesso in scrittura alle risorse distribuite e l'accesso a tutte le operazioni sul tipo di risorsa Microsoft.Resources/deployments. Ad esempio, per distribuire una macchina virtuale, 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.

Dopo aver distribuito il cluster dal modello, è possibile usare l'interfaccia della riga di comando di Azure o Azure PowerShell per connettersi al cluster e distribuire l'applicazione di esempio.

Registrare i provider di risorse necessari

Potrebbe essere necessario registrare i provider di risorse necessari, ad esempio Microsoft.ContainerService nella sottoscrizione Azure.

Controllare lo stato della registrazione

Controllare lo stato della registrazione usando il az provider show comando .

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

Registrare il provider di risorse

Se necessario, registrare il provider di risorse Microsoft.ContainerService usando il comando az provider register.

az provider register --namespace Microsoft.ContainerService

Creare una coppia di chiavi SSH

Per creare un cluster del servizio Azure Kubernetes usando un modello di Resource Manager, è necessario specificare una chiave pubblica SSH. Se è necessaria questa risorsa, seguire la procedura descritta in questa sezione. In caso contrario, passare direttamente alla sezione Esamina il modello .

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

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

2. Creare un gruppo di risorse usando il comando az group create. L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nell'area Stati Uniti orientali :

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

3. Creare una coppia di chiavi SSH usando il az sshkey create comando o il ssh-keygen comando .

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

   In alternativa, creare una coppia di chiavi SSH usando ssh-keygen:

   ssh-keygen -t rsa -b 4096
   

4. Per distribuire il modello, è necessario fornire la chiave pubblica dalla coppia SSH. Recuperare la chiave pubblica usando il az sshkey show comando .

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

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",
  "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]"
    }
  }
}

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

Per altri esempi per il servizio Azure Kubernetes, vedere il sito dei modelli di avvio rapido per il servizio Azure Kubernetes.

Implementare il modello

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

   

2. Configurare i parametri del modello nella pagina Distribuzione personalizzata . Per questa guida introduttiva, lasciare i valori predefiniti per Dimensioni disco del sistema operativo GB, Numero agenti, Dimensioni macchina virtuale agente e Tipo di sistema operativo. Specificare i propri valori per i parametri seguenti:

   • Sottoscrizione: selezionare una sottoscrizione di Azure.
   • Gruppo di risorse: selezionare Crea nuovo. Specificare un nome univoco per il gruppo di risorse, ad esempio myResourceGroup, quindi scegliere OK.
   • SKU del sistema operativo: specificare AzureContainerLinux. Se non si aggiorna lo SKU del sistema operativo, il valore predefinito è Ubuntu.
   • Località: selezionare una località, ad esempio Stati Uniti orientali.
   • Nome cluster: immettere un nome univoco per il cluster del servizio Azure Kubernetes, ad esempio myAKSCluster.
   • Prefisso DNS: inserire un prefisso DNS univoco per il cluster, ad esempio myakscluster.
   • 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 del cluster prima di procedere al passaggio successivo.

Connettersi al cluster

Per gestire un cluster Kubernetes, usare il client da riga di comando kubernetes kubectl. Se si usa Azure Cloud Shell, kubectl è già installato.

Distribuire l'applicazione

Per distribuire l'applicazione, utilizzare un file manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione AKS Store. Un file manifesto Kubernetes definisce lo stato desiderato di un cluster, ad esempio le immagini del contenitore da eseguire. Il manifesto include le distribuzioni e i servizi Kubernetes seguenti:

• Vetrina di vendita: applicazione Web che consente ai clienti di visualizzare i prodotti ed effettuare ordini.
• Servizio prodotto: mostra le informazioni sul prodotto.
• Servizio ordini: effettua ordini.
• Rabbit MQ: coda di messaggi per gestire gli ordini.

1. Creare un file denominato aks-store-quickstart.yaml e copiarlo nel manifesto seguente:

   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
   

   Per un dettaglio dei file manifesto YAML, vedere Distribuzioni e manifesti YAML.

   Se si crea e si salva il file YAML in locale, è possibile caricare il file manifesto nella directory predefinita in CloudShell facendo clic sul pulsante Carica/Scarica file e selezionando il file dal file system locale.

2. Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.

   kubectl apply -f aks-store-quickstart.yaml
   

   L'output di esempio seguente mostra le distribuzioni e i servizi:

   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
   

Testare l'applicazione

1. Controllare lo stato dei pod distribuiti usando il comando kubectl get pods. Fare in modo che tutti i pod siano Running prima di procedere.

   kubectl get pods
   

2. Verificare la presenza di un indirizzo IP pubblico per l'applicazione front-store. Monitorare lo stato di avanzamento usando il comando kubectl get service con l'argomento --watch.

   kubectl get service store-front --watch
   

   L'output EXTERNAL-IP per il servizio store-front inizialmente viene visualizzato come in sospeso:

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

3. Quando l'indirizzo EXTERNAL-IP passa da in sospeso a un effettivo indirizzo IP pubblico, usare CTRL-C per arrestare il processo di controllo kubectl.

   L'output di esempio seguente mostra un indirizzo IP pubblico valido assegnato al servizio:

   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. Aprire un Web browser all'indirizzo IP esterno del servizio per visualizzare l'app di Azure Store in azione:

   

Eliminare il cluster

Se non si prevede di seguire il tutorial AKS, ripulire le risorse non necessarie per evitare costi su Azure.

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

Remove-AzResourceGroup -Name myResourceGroup -Force

Contenuti correlati

In questa guida introduttiva hai distribuito un cluster AKS con ACL per AKS usando un modello ARM. Per altre informazioni sull'ACL per il servizio Azure Kubernetes, vedere Azure Container Linux (ACL) per Servizio Azure Kubernetes (AKS).