Share via

Avvio rapido: Creare un cluster Azure Nexus Kubernetes usando l'interfaccia della riga di comando di Azure

  • Articolo
  • Distribuire un cluster Kubernetes Nexus di Azure usando l'interfaccia della riga di comando di Azure.

Operazioni preliminari

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

  • Installare la versione più recente delle estensioni dell'interfaccia della riga di comando di Azure necessarie.

  • Questo articolo richiede la versione 2.49.0 o successiva dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.

  • Se sono presenti più sottoscrizioni di Azure, selezionare l'ID sottoscrizione appropriato in cui devono essere fatturate le risorse usando il az account comando .

  • Per l'elenco degli SKU di macchine virtuali supportati, vedere la tabella SKU della macchina virtuale nella sezione di riferimento.

  • Per l'elenco delle versioni di Kubernetes supportate, vedere le versioni di Kubernetes supportate.

  • Creare un gruppo di risorse usando il comando az group create. Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite. Quando si crea un gruppo di risorse, viene richiesto di specificare una posizione. Questa posizione è la posizione di archiviazione dei metadati del gruppo di risorse e dove le risorse vengono eseguite in Azure se non si specifica un'altra regione durante la creazione della risorsa. L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nella località stati uniti orientali.

    az group create --name myResourceGroup --location eastus

    L'esempio di output seguente è simile alla corretta creazione del gruppo di risorse:

    {
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

  • Per distribuire un file Bicep o un modello di ARM, è necessario l'accesso in scrittura alle risorse distribuite e l'accesso per tutte le operazioni sul tipo di risorsa Microsoft.Resources/deployments. Ad esempio, per distribuire un cluster, sono necessarie autorizzazioni Microsoft.NetworkCloud/kubernetesclusters/write e Microsoft.Resources/deployments/* . Per un elenco dei ruoli e delle autorizzazioni, vedere Ruoli predefiniti di Azure.

  • È necessario l'ID risorsa del cluster Nexus dell'operatore custom location di Azure.

  • È necessario creare diverse reti in base ai requisiti specifici del carico di lavoro ed è essenziale avere gli indirizzi IP appropriati disponibili per i carichi di lavoro. Per garantire un'implementazione uniforme, è consigliabile consultare i team di supporto pertinenti per assistenza.

  • Questa guida introduttiva presuppone una comprensione di base dei concetti relativi a Kubernetes. Per altre informazioni, vedere Concetti di base relativi a Kubernetes per il servizio Azure Kubernetes.

Creare un cluster Kubernetes Di Azure Nexus

L'esempio seguente crea un cluster denominato myNexusK8sCluster nel gruppo di risorse myResourceGroup nella posizione eastus.

Prima di eseguire i comandi, è necessario impostare diverse variabili per definire la configurazione per il cluster. Ecco le variabili da impostare, insieme ad alcuni valori predefiniti che è possibile usare per determinate variabili:

Variabile Descrizione
LOCATION Area di Azure in cui si vuole creare il cluster.
RESOURCE_GROUP Nome del gruppo di risorse di Azure in cui si vuole creare il cluster.
SUBSCRIPTION_ID ID della sottoscrizione di Azure.
CUSTOM_LOCATION Questo argomento specifica una posizione personalizzata dell'istanza Nexus.
CSN_ARM_ID L'ID CSN è l'identificatore univoco per la rete di servizi cloud che si vuole usare.
CNI_ARM_ID L'ID CNI è l'identificatore univoco dell'interfaccia di rete da usare dal runtime del contenitore.
AAD_ADMIN_GROUP_OBJECT_ID ID oggetto del gruppo Microsoft Entra che deve avere privilegi di amministratore nel cluster.
CLUSTER_NAME Nome da assegnare al cluster Nexus Kubernetes.
K8S_VERSION Versione di Kubernetes da usare.
ADMIN_U edizione Standard RNAME Nome utente per l'amministratore del cluster.
SSH_PUBLIC_KEY Chiave pubblica SSH usata per la comunicazione sicura con il cluster.
CONTROL_PLANE_COUNT Numero di nodi del piano di controllo per il cluster.
CONTROL_PLANE_VM_SIZE Dimensioni della macchina virtuale per i nodi del piano di controllo.
INITIAL_AGENT_POOL_NAME Nome del pool di agenti iniziale.
INITIAL_AGENT_POOL_COUNT Numero di nodi nel pool di agenti iniziale.
INITIAL_AGENT_POOL_VM_SIZE Dimensioni della macchina virtuale per il pool di agenti iniziale.
POD_CIDR Intervallo di rete per i pod Kubernetes nel cluster, in notazione CIDR.
edizione Standard RVICE_CIDR Intervallo di rete per i servizi Kubernetes nel cluster, nella notazione CIDR.
DNS_edizione Standard RVICE_IP Indirizzo IP per il servizio DNS Kubernetes.

Dopo aver definito queste variabili, è possibile eseguire il comando dell'interfaccia della riga di comando di Azure per creare il cluster. Aggiungere il --debug flag alla fine per fornire output più dettagliato a scopo di risoluzione dei problemi.

Per definire queste variabili, usare i comandi set seguenti e sostituire i valori di esempio con i valori preferiti. È anche possibile usare i valori predefiniti per alcune delle variabili, come illustrato nell'esempio seguente:

RESOURCE_GROUP="myResourceGroup"
SUBSCRIPTION_ID="<Azure subscription ID>"
LOCATION="$(az group show --name $RESOURCE_GROUP --query location --subscription $SUBSCRIPTION_ID -o tsv)"
CUSTOM_LOCATION="/subscriptions/<subscription_id>/resourceGroups/<managed_resource_group>/providers/microsoft.extendedlocation/customlocations/<custom-location-name>"
CSN_ARM_ID="/subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.NetworkCloud/cloudServicesNetworks/<csn-name>"
CNI_ARM_ID="/subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.NetworkCloud/l3Networks/<l3Network-name>"
AAD_ADMIN_GROUP_OBJECT_ID="00000000-0000-0000-0000-000000000000"
CLUSTER_NAME="myNexusK8sCluster"
K8S_VERSION="v1.24.9"
ADMIN_USERNAME="azureuser"
SSH_PUBLIC_KEY="$(cat ~/.ssh/id_rsa.pub)"
CONTROL_PLANE_COUNT="1"
CONTROL_PLANE_VM_SIZE="NC_G6_28_v1"
INITIAL_AGENT_POOL_NAME="${CLUSTER_NAME}-nodepool-1"
INITIAL_AGENT_POOL_COUNT="1"
INITIAL_AGENT_POOL_VM_SIZE="NC_P10_56_v1"
POD_CIDR="10.244.0.0/16"
SERVICE_CIDR="10.96.0.0/16"
DNS_SERVICE_IP="10.96.0.10"

Importante

È essenziale sostituire i segnaposto per CUSTOM_LOCATION, CSN_ARM_ID, CNI_ARM_ID e AAD_ADMIN_GROUP_OBJECT_ID con i valori effettivi prima di eseguire questi comandi.

Dopo aver definito queste variabili, è possibile creare il cluster Kubernetes eseguendo il comando seguente dell'interfaccia della riga di comando di Azure:

az networkcloud kubernetescluster create \
  --name "${CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --subscription "${SUBSCRIPTION_ID}" \
  --extended-location name="${CUSTOM_LOCATION}" type=CustomLocation \
  --location "${LOCATION}" \
  --kubernetes-version "${K8S_VERSION}" \
  --aad-configuration admin-group-object-ids="[${AAD_ADMIN_GROUP_OBJECT_ID}]" \
  --admin-username "${ADMIN_USERNAME}" \
  --ssh-key-values "${SSH_PUBLIC_KEY}" \
  --control-plane-node-configuration \
    count="${CONTROL_PLANE_COUNT}" \
    vm-sku-name="${CONTROL_PLANE_VM_SIZE}" \
  --initial-agent-pool-configurations "[{count:${INITIAL_AGENT_POOL_COUNT},mode:System,name:${INITIAL_AGENT_POOL_NAME},vm-sku-name:${INITIAL_AGENT_POOL_VM_SIZE}}]" \
  --network-configuration \
    cloud-services-network-id="${CSN_ARM_ID}" \
    cni-network-id="${CNI_ARM_ID}" \
    pod-cidrs="[${POD_CIDR}]" \
    service-cidrs="[${SERVICE_CIDR}]" \
    dns-service-ip="${DNS_SERVICE_IP}"

Se non è disponibile una capacità sufficiente per distribuire i nodi del cluster richiesti, viene visualizzato un messaggio di errore. Tuttavia, questo messaggio non fornisce dettagli sulla capacità disponibile. Indica che la creazione del cluster non può continuare a causa di capacità insufficiente.

Nota

Il calcolo della capacità prende in considerazione l'intero cluster della piattaforma, anziché essere limitato ai singoli rack. Pertanto, se un pool di agenti viene creato in una zona (in cui un rack è uguale a una zona) con capacità insufficiente, ma un'altra zona ha una capacità sufficiente, la creazione del cluster continua ma alla fine si verifica un timeout. Questo approccio al controllo della capacità ha senso solo se non viene specificata una zona specifica durante la creazione del cluster o del pool di agenti.

Il comando viene completato dopo pochi minuti e vengono restituite informazioni sul cluster. Per altre opzioni avanzate, vedere Avvio rapido: Distribuire un cluster Kubernetes Nexus di Azure con Bicep.

Esaminare le risorse distribuite

Al termine della distribuzione, è possibile visualizzare le risorse usando l'interfaccia della riga di comando o il portale di Azure.

Per visualizzare i dettagli del myNexusK8sCluster cluster nel gruppo di risorse, eseguire il comando seguente dell'interfaccia della myResourceGroup riga di comando di Azure:

az networkcloud kubernetescluster show \
  --name myNexusK8sCluster \
  --resource-group myResourceGroup

Per ottenere un elenco di nomi di pool di agenti associati al myNexusK8sCluster cluster nel myResourceGroup gruppo di risorse, è anche possibile usare il comando seguente dell'interfaccia della riga di comando di Azure.

az networkcloud kubernetescluster agentpool list \
  --kubernetes-cluster-name myNexusK8sCluster \
  --resource-group myResourceGroup \
  --output table

Stabilire la connessione al cluster

Ora che il cluster Nexus Kubernetes è stato creato e connesso ad Azure Arc, è possibile connettersi facilmente usando la funzionalità di connessione del cluster. La connessione cluster consente di accedere e gestire in modo sicuro il cluster da qualsiasi posizione, semplificando lo sviluppo interattivo, il debug e le attività di amministrazione del cluster.

Per informazioni più dettagliate sulle opzioni disponibili, vedere Connessione a un cluster Nexus Kubernetes dell'operatore di Azure.

Nota

Quando si crea un cluster Nexus Kubernetes, Nexus crea automaticamente un gruppo di risorse gestito dedicato all'archiviazione delle risorse del cluster, all'interno di questo gruppo, viene stabilita la risorsa cluster connessa Arc.

Per accedere al cluster, è necessario configurare il cluster connect kubeconfig. Dopo aver eseguito l'accesso all'interfaccia della riga di comando di Azure con l'entità Microsoft Entra pertinente, è possibile ottenere il kubeconfig necessario per comunicare con il cluster ovunque, anche all'esterno del firewall che lo circonda.

  1. Impostare CLUSTER_NAMEle variabili e RESOURCE_GROUPSUBSCRIPTION_ID .

    CLUSTER_NAME="myNexusK8sCluster"
RESOURCE_GROUP="myResourceGroup"
SUBSCRIPTION_ID=<set the correct subscription_id>

  2. Eseguire query sul gruppo di risorse gestite con az e archiviare in MANAGED_RESOURCE_GROUP

     az account set -s $SUBSCRIPTION_ID
 MANAGED_RESOURCE_GROUP=$(az networkcloud kubernetescluster show -n $CLUSTER_NAME -g $RESOURCE_GROUP --output tsv --query managedResourceGroupConfiguration.name)

  3. Il comando seguente avvia un proxy connectedk8s che consente di connettersi al server API Kubernetes per il cluster Nexus Kubernetes specificato.

    az connectedk8s proxy -n $CLUSTER_NAME  -g $MANAGED_RESOURCE_GROUP &

  4. Usare kubectl per inviare richieste al cluster:

    kubectl get pods -A

    Verrà visualizzata una risposta dal cluster contenente l'elenco di tutti i nodi.

Nota

Se viene visualizzato il messaggio di errore "Failed to post access token to client proxyFailed to connect to MSI", potrebbe essere necessario eseguire un az login per eseguire di nuovo l'autenticazione con Azure.

Aggiungere un pool di agenti

Il cluster creato nel passaggio precedente ha un singolo pool di nodi. Aggiungere un secondo pool di agenti usando il az networkcloud kubernetescluster agentpool create comando . L'esempio seguente crea un pool di agenti denominato myNexusK8sCluster-nodepool-2:

È anche possibile usare i valori predefiniti per alcune delle variabili, come illustrato nell'esempio seguente:

RESOURCE_GROUP="myResourceGroup"
CUSTOM_LOCATION="/subscriptions/<subscription_id>/resourceGroups/<managed_resource_group>/providers/microsoft.extendedlocation/customlocations/<custom-location-name>"
CLUSTER_NAME="myNexusK8sCluster"
AGENT_POOL_NAME="${CLUSTER_NAME}-nodepool-2"
AGENT_POOL_VM_SIZE="NC_P10_56_v1"
AGENT_POOL_COUNT="1"
AGENT_POOL_MODE="User"

Dopo aver definito queste variabili, è possibile aggiungere un pool di agenti eseguendo il comando seguente dell'interfaccia della riga di comando di Azure:

az networkcloud kubernetescluster agentpool create \
  --name "${AGENT_POOL_NAME}" \
  --kubernetes-cluster-name "${CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --subscription "${SUBSCRIPTION_ID}" \
  --extended-location name="${CUSTOM_LOCATION}" type=CustomLocation \
  --count "${AGENT_POOL_COUNT}" \
  --mode "${AGENT_POOL_MODE}" \
  --vm-sku-name "${AGENT_POOL_VM_SIZE}"

Dopo alcuni minuti, il comando viene completato e restituisce informazioni sul pool di agenti. Per altre opzioni avanzate, vedere Avvio rapido: Distribuire un cluster Kubernetes Nexus di Azure con Bicep.

Nota

È possibile aggiungere più pool di agenti durante la creazione iniziale del cluster stesso usando le configurazioni iniziali del pool di agenti. Tuttavia, se si vogliono aggiungere pool di agenti dopo la creazione iniziale, è possibile usare il comando precedente per creare pool di agenti aggiuntivi per il cluster Nexus Kubernetes.

L'esempio di output seguente è simile alla corretta creazione del pool di agenti.

$ az networkcloud kubernetescluster agentpool list --kubernetes-cluster-name myNexusK8sCluster --resource-group myResourceGroup --output table
This command is experimental and under development. Reference and support levels: https://aka.ms/CLI_refstatus
Count    Location    Mode    Name                          ProvisioningState    ResourceGroup    VmSkuName
-------  ----------  ------  ----------------------------  -------------------  ---------------  -----------
1        eastus      System  myNexusK8sCluster-nodepool-1  Succeeded            myResourceGroup  NC_P10_56_v1
1        eastus      User    myNexusK8sCluster-nodepool-2  Succeeded            myResourceGroup  NC_P10_56_v1

Pulire le risorse

Quando non è più necessario, eliminare il gruppo di risorse. Il gruppo di risorse e tutte le risorse nel gruppo di risorse vengono eliminati.

Usare il comando az group delete per rimuovere il gruppo di risorse, il cluster Kubernetes e tutte le risorse correlate, ad eccezione delle risorse di rete Operator Nexus.

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

Passaggi successivi

È ora possibile distribuire le funzioni di rete direttamente tramite la connessione del cluster o tramite Azure Operator Service Manager.