Condividi tramite

Avvio rapido: Creare un cluster Kubernetes Nexus di Azure 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.61.0 o successiva dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.

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

  • Per l'elenco degli SKU di VM supportati, vedere la tabella degli SKU della VM 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 custom location del cluster Operatore Nexus 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 Nexus di Azure

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 desidera creare il cluster.
RESOURCE_GROUP Nome del gruppo di risorse di Azure in cui si desidera 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 desidera 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 Kubernetes Nexus.
K8S_VERSION Versione di Kubernetes che si desidera usare.
ADMIN_USERNAME 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 Le 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.
SERVICE_CIDR Intervallo di rete per i servizi Kubernetes nel cluster, in notazione CIDR.
DNS_SERVICE_IP L'indirizzo IP del servizio DNS di Kubernetes.

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

Per definire queste variabili, usare i seguenti comandi 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_SSH_PUBLIC_KEY="$(cat ~/.ssh/id_rsa.pub)"
AGENT_POOL_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}" \
    ssh-key-values='["${CONTROL_PLANE_SSH_PUBLIC_KEY}"]' \
  --initial-agent-pool-configurations "[{count:${INITIAL_AGENT_POOL_COUNT},mode:System,name:${INITIAL_AGENT_POOL_NAME},vm-sku-name:${INITIAL_AGENT_POOL_VM_SIZE},ssh-key-values:['${AGENT_POOL_SSH_PUBLIC_KEY}']}]" \
  --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 cluster myNexusK8sCluster nel gruppo di risorse myResourceGroup, eseguire il comando dell'interfaccia della riga di comando di Azure seguente:

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

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

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

Stabilire la connessione al cluster

Ora che il cluster Kubernetes Nexus è 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 Connettersi a un cluster Kubernetes Nexus dell'operatore di Azure.

Nota

Quando si crea un cluster Kubernetes Nexus, 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 la connessione del cluster 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 da qualsiasi posizione, anche all'esterno del firewall che lo circonda.

  1. Impostare le variabili CLUSTER_NAME, RESOURCE_GROUP e SUBSCRIPTION_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 Kubernetes Nexus 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.

Aggiungi un pool di agenti

Il cluster creato nel passaggio precedente ha un singolo pool di nodi. Aggiungere un secondo pool di agenti usando il comando az networkcloud kubernetescluster agentpool create. Nell'esempio seguente viene creato 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}"

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

Nota

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

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.