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

Articolo
11/23/2024

Si applica a: Locale di Azure, versione 23H2

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 versione 23H2 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 sottoscrizione di Azure: ID sottoscrizione di Azure in cui viene usato Locale di Azure per la distribuzione e la registrazione.
- ID percorso personalizzato - 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 deve fornire l'ID resource manager 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. Assicurarsi di avere la versione più recente dell'interfaccia della riga di comando di Az nel 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 nei 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 az aksarc create comando 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.

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.

Nota

Il valore della chiave SSH è la chiave pubblica per l'accesso ai nodi nel cluster di cui è stato effettuato il provisioning. Per impostazione predefinita, questa chiave si trova in ~/.ssh/id_rsa.pub. È possibile specificare un percorso diverso usando il parametro durante la --ssh-key-value creazione del cluster.
Il --generate-ssh-keys parametro è obbligatorio se non è presente una chiave SSH preesistente nel computer locale. Se non si include questo parametro 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 riutilizza tale chiave. In questo caso, specificando --generate-ssh-keyso omettendo tale parametro, non ha alcun effetto.

Importante

Per usare il controllo degli accessi in base al ruolo di Azure o l'identità del carico di lavoro per un cluster del servizio Azure Kubernetes, è necessario passare i parametri necessari durante la creazione del cluster usando l'interfaccia della riga di comando di Azure. Attualmente, l'aggiornamento di un cluster del servizio Azure Kubernetes esistente per abilitare l'identità del carico di lavoro e/o il controllo degli accessi in base al ruolo di Azure non è supportato. Per altre informazioni, vedere Usare il controllo degli accessi in base al ruolo di Azure per l'autorizzazione kubernetes o 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.

Mantenere questa sessione in esecuzione e connettersi al cluster Kubernetes da un terminale o un prompt dei comandi 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

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 include 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 correttamente:

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

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 inizialmente viene visualizzato 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 dall'indirizzo IP in sospeso a un indirizzo IP pubblico effettivo, usare CTRL-C per arrestare il processo di controllo 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 --resource-group $aksclustername --name $resource_group

Passaggi successivi

Risolvere i problemi noti relativi al provisioning del cluster da Azure

Condividi tramite