Creare cluster Kubernetes usando l'interfaccia della riga di comando di Azure

2025-04-08

Si applica a: AKS locale su Azure

Questo articolo descrive come creare cluster Kubernetes in Locale di Azure usando l'interfaccia della riga di comando di Azure. Il flusso di lavoro prevede le fasi seguenti:

Creare un cluster Kubernetes in Locale di Azure usando l'interfaccia della riga di comando di Azure. Il cluster è connesso ad Azure Arc per impostazione predefinita.
Durante la creazione del cluster, si fornisce un gruppo Microsoft Entra che contiene l'elenco di utenti di Microsoft Entra con accesso amministratore del cluster Kubernetes.
Accedere al cluster usando kubectl e l'ID Microsoft Entra.
Eseguire un'applicazione multi-contenitore di esempio con un front-end Web e un'istanza di Redis nel cluster.

Operazioni preliminari

Prima di iniziare, assicurarsi di avere i dettagli seguenti dall'amministratore dell'infrastruttura locale:
- ID della sottoscrizione Azure - L'ID della sottoscrizione Azure in cui Azure Local viene utilizzato per la distribuzione e la registrazione.
- ID della posizione personalizzata - ID di Azure Resource Manager della posizione personalizzata. Il percorso personalizzato viene configurato durante la distribuzione del cluster locale di Azure. L'amministratore dell'infrastruttura dovrebbe fornirti l'ID del manager delle risorse della posizione personalizzata. Questo parametro è obbligatorio per creare cluster Kubernetes. È anche possibile ottenere l'ID di Resource Manager usando az customlocation show --name "<custom location name>" --resource-group <azure resource group> --query "id" -o tsv, se l'amministratore dell'infrastruttura fornisce un nome di percorso personalizzato e un nome del gruppo di risorse.
- ID di rete: ID di Azure Resource Manager della rete logica locale di Azure creata seguendo questa procedura. L'amministratore deve fornire l'ID della rete logica. Questo parametro è obbligatorio per creare cluster Kubernetes. È anche possibile ottenere l'ID di Azure Resource Manager usando az stack-hci-vm network lnet show --name "<lnet name>" --resource-group <azure resource group> --query "id" -o tsv se si conosce il gruppo di risorse in cui è stata creata la rete logica.
È possibile eseguire i passaggi descritti in questo articolo in un computer di sviluppo locale per creare un cluster Kubernetes nella distribuzione locale di Azure remota. Assicurati di avere l'ultima versione di Az CLI sul computer di sviluppo. È anche possibile scegliere di aggiornare la versione dell'interfaccia della riga di comando di Az usando az upgrade.
Per connettersi al cluster Kubernetes da qualsiasi posizione, creare un gruppo Microsoft Entra e aggiungervi membri. Tutti i membri del gruppo Microsoft Entra hanno accesso come amministratore del cluster al cluster. Assicurarsi di aggiungere se stessi come membro al gruppo Microsoft Entra. Se non si aggiunge se stessi, non è possibile accedere al cluster Kubernetes usando kubectl. Per altre informazioni sulla creazione di gruppi di Microsoft Entra e sull'aggiunta di utenti, vedere Gestire i gruppi di Microsoft Entra e l'appartenenza ai gruppi.
Scaricare e installare kubectl nel computer di sviluppo. Lo strumento da riga di comando Kubernetes, kubectl, consente di eseguire comandi sui cluster Kubernetes. È possibile usare kubectl per distribuire applicazioni, esaminare e gestire le risorse del cluster e visualizzare i log.

Installare l'estensione dell'interfaccia della riga di comando di Azure.

Eseguire il comando seguente per installare le estensioni dell'interfaccia della riga di comando di Azure necessarie:

az extension add -n aksarc --upgrade
az extension add -n customlocation --upgrade
az extension add -n stack-hci-vm --upgrade
az extension add -n connectedk8s --upgrade

Creare un cluster Kubernetes

Usare il comando az aksarc create per creare un cluster Kubernetes in AKS Arc. Assicurarsi di accedere ad Azure prima di eseguire questo comando. Se si hanno più sottoscrizioni di Azure, selezionare l'ID sottoscrizione appropriato usando il comando az account set. Con il az aksarc create comando è consigliabile usare il --validate flag , che convalida i parametri di input che si intende usare. Dopo aver convalidato i parametri di input, è possibile eseguire il az aksarc create comando senza il --validate flag per creare il cluster Kubernetes.

az aksarc create -n $aksclustername -g $resource_group --custom-location $customlocationID --vnet-ids $logicnetId --aad-admin-group-object-ids $aadgroupID --generate-ssh-keys

Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Considerazioni

Quando si crea un cluster, tenere presenti le considerazioni seguenti:

Le chiavi SSH sono essenziali per la risoluzione dei problemi e la raccolta di log. Assicurarsi di salvare il file di chiave privata per un uso futuro. Per accedere ai nodi, vedere Connettersi ai nodi di lavoro Windows o Linux con SSH.
È possibile usare una chiave SSH preesistente o configurare chiavi SSH per un cluster del servizio Azure Kubernetes durante la creazione del cluster. Se nel computer locale non è presente alcuna chiave SSH preesistente, il --generate-ssh-keys parametro è obbligatorio. È anche possibile limitare l'accesso SSH seguendo la documentazione. Per istruzioni dettagliate, vedere Creare e archiviare chiavi SSH con l'interfaccia della riga di comando di Azure o nel portale di Azure.
Se non si include --generate-ssh-keys durante la creazione del cluster e non esiste alcuna chiave SSH, viene visualizzato un messaggio di errore. Se nel computer locale è già presente una chiave SSH, il cluster del servizio Azure Kubernetes lo riutilizza. In questo caso, non fa differenza se si specifica --generate-ssh-keys o meno.
Per impostazione predefinita, la chiave SSH viene archiviata in ~/.ssh/id_rsa.pub. Durante la creazione del cluster, è possibile specificare un percorso alternativo usando il --ssh-key-value parametro .

Importante

Per usare Azure RBAC o l'identità del carico di lavoro per un cluster di Azure Kubernetes Service, è necessario passare i parametri richiesti durante la creazione del cluster usando Azure CLI. Attualmente, l'aggiornamento di un cluster AKS esistente per abilitare Workload Identity e/o Azure RBAC non è supportato. Per altre informazioni, vedere Usare il controllo degli accessi in base al ruolo di Azure per l'autorizzazione di Kubernetes oppure Distribuire e configurare l'identità del carico di lavoro per il cluster.

Connettersi al cluster Kubernetes

È ora possibile connettersi al cluster Kubernetes eseguendo il az connectedk8s proxy comando dal computer di sviluppo. Assicurarsi di accedere ad Azure prima di eseguire questo comando. Se si hanno più sottoscrizioni di Azure, selezionare l'ID sottoscrizione appropriato usando il comando az account set.

Questo comando scarica kubeconfig del cluster Kubernetes nel computer di sviluppo e apre un canale di connessione proxy al cluster Kubernetes locale. Il canale è aperto finché il comando viene eseguito. Consentire l'esecuzione di questo comando per tutto il tempo necessario per accedere al cluster. Se si verifica il timeout, chiudere la finestra dell'interfaccia della riga di comando, aprirne una nuova, quindi eseguire di nuovo il comando.

Per eseguire correttamente il comando seguente, è necessario disporre delle autorizzazioni di Collaboratore per il gruppo di risorse che ospita il cluster Kubernetes:

az connectedk8s proxy --name $aksclustername --resource-group $resource_group --file .\aks-arc-kube-config

Output previsto:

Proxy is listening on port 47011
Merged "aks-workload" as current context in .\\aks-arc-kube-config
Start sending kubectl requests on 'aks-workload' context using
kubeconfig at .\\aks-arc-kube-config
Press Ctrl+C to close proxy.

Mantieni questa sessione in esecuzione e connettiti al cluster Kubernetes da un terminale/comando prompt diverso. Verificare che sia possibile connettersi al cluster Kubernetes eseguendo il comando kubectl get. Questo comando restituisce un elenco dei nodi del cluster:

kubectl get node -A --kubeconfig .\aks-arc-kube-config

L'esempio di output seguente mostra il nodo creato nei passaggi precedenti. Assicurarsi che lo stato del nodo sia Pronto:

NAME             STATUS ROLES                AGE VERSION
moc-l0ttdmaioew  Ready  control-plane,master 34m v1.24.11
moc-ls38tngowsl  Ready  <none>               32m v1.24.11

Distribuire l'applicazione e il servizio di bilanciamento del carico

Un file manifesto Kubernetes definisce lo stato desiderato di un cluster, ad esempio le immagini del contenitore da eseguire.

È possibile usare un manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione Azure Vote. Questo manifesto includono due distribuzioni Kubernetes:

Applicazioni Python di Azure Vote di esempio.
Istanza di Redis.

Vengono creati anche due servizi Kubernetes:

Servizio interno per l'istanza di Redis.
Un servizio esterno per accedere all'applicazione Azure Vote da Internet.

Creare un file denominato azure-vote.yaml e copiarlo nel manifesto seguente:

apiVersion: apps/v1 
    kind: Deployment 
    metadata: 
      name: azure-vote-back 
    spec: 
      replicas: 1 
      selector: 
        matchLabels: 
          app: azure-vote-back 
      template: 
        metadata: 
          labels: 
            app: azure-vote-back 
        spec: 
          nodeSelector: 
            "kubernetes.io/os": linux 
          containers: 
          - name: azure-vote-back 
            image: <path to image>/oss/bitnami/redis:6.0.8 
            env: 
            - name: ALLOW_EMPTY_PASSWORD 
              value: "yes" 
            resources: 
              requests: 
                cpu: 100m 
                memory: 128Mi 
              limits: 
                cpu: 250m 
                memory: 256Mi 
            ports: 
            - containerPort: 6379 
              name: redis 
    ---
    apiVersion: v1
    kind: Service 
    metadata: 
      name: azure-vote-back 
    spec: 
      ports: 
      - port: 6379 
      selector: 
        app: azure-vote-back 
    --- 
    apiVersion: apps/v1 
    kind: Deployment 
    metadata: 
      name: azure-vote-front 
    spec: 
      replicas: 1 
      selector: 
        matchLabels: 
          app: azure-vote-front 
      template: 
        metadata: 
          labels: 
            app: azure-vote-front 
        spec: 
          nodeSelector: 
            "kubernetes.io/os": linux 
          containers: 
          - name: azure-vote-front 
            image: <path to image>/azure-vote-front:v1 
            resources: 
              requests: 
                cpu: 100m 
                memory: 128Mi 
              limits: 
                cpu: 250m 
                memory: 256Mi 
            ports: 
            - containerPort: 80 
            env: 
            - name: REDIS 
              value: "azure-vote-back" 
    --- 
    apiVersion: v1 
    kind: Service 
    metadata: 
      name: azure-vote-front 
    spec: 
      type: LoadBalancer 
      ports: 
      - port: 80 
      selector: 
        app: azure-vote-front

Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del file YAML:

kubectl apply -f azure-vote.yaml --kubeconfig .\\aks-arc-kube-config

L'output di esempio seguente mostra le distribuzioni e i servizi creati con successo.

deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-front" created

Distribuire un servizio di bilanciamento del carico MetalLB in modo che possa assegnare un indirizzo IP esterno per il front-end dell'applicazione. È possibile seguire queste istruzioni per distribuire l'estensione MetalLB dal portale di Azure o tramite l'interfaccia della riga di comando.

Testare l'applicazione

Durante l'esecuzione dell'applicazione, un servizio Kubernetes espone il front-end dell'applicazione a Internet. Questo processo può richiedere alcuni minuti.

Monitorare lo stato di avanzamento usando il comando kubectl get service con l'argomento --watch .

kubectl get service azure-vote-front --watch --kubeconfig .\aks-arc-kube-config

L'output EXTERNAL-IP per il servizio azure-vote-front appare inizialmente come in sospeso.

NAME             TYPE         CLUSTER-IP EXTERNAL-IP PORT(S)      AGE
azure-vote-front LoadBalancer 10.0.37.27 <pending>   80:30572/TCP 6s

Quando l'indirizzo EXTERNAL-IP passa da non configurato a un indirizzo IP pubblico effettivo, usare CTRL-C per arrestare il processo di monitoraggio di kubectl. L'output di esempio seguente mostra un indirizzo IP pubblico valido assegnato al servizio:

azure-vote-front LoadBalancer 10.0.37.27 52.179.23.131 80:30572/TCP 2m

Per visualizzare l'app Azure Vote in azione, aprire un browser Web all'indirizzo IP esterno del servizio.

Eliminare il cluster

Eseguire il az aksarc delete comando per pulire il cluster creato:

az aksarc delete --name $aksclustername --resource-group $resource_group

Passaggi successivi

Risolvere i problemi noti relativi al provisioning del cluster in Azure 6