Condividi tramite

Connettersi a un cluster di integrazione rete virtuale del server API tramite collegamento privato di Azure

Con l'integrazione del server API nella VNet, il piano di controllo di AKS è accessibile tramite un indirizzo IP privato all'interno della rete virtuale del cluster. Questa configurazione funziona bene per i carichi di lavoro in esecuzione nella stessa rete virtuale, ma non copre automaticamente le reti esterne, ad esempio una rete hub, una rete virtuale per le operazioni dedicate o un ambiente jump-host che deve raggiungere il server API senza esporlo alla rete Internet pubblica. Questo articolo ti mostra come stabilire una connessione al server API utilizzando un servizio di collegamento privato e quindi connettersi a esso da una rete virtuale separata tramite un endpoint privato.

Questo articolo si applica solo ai cluster AKS privati creati con l'integrazione della rete virtuale del server API e che utilizzano una configurazione bring-your-own VNet (BYO VNet). Scopri come:

  • Distribuire un cluster privato AKS con l'integrazione della Rete Virtuale per il server API utilizzando il proprio VNet.
  • Esporre il server API tramite un servizio di collegamento privato (PLS) all'interno della rete virtuale del cluster.
  • Creare un endpoint privato (PE) in una rete virtuale diversa.
  • Configurare il DNS privato affinché gli strumenti Kubernetes risolvano il nome di dominio completo del cluster all'interno della rete remota.

Per i cluster privati che non usano l'integrazione della rete virtuale del server API, vedere Creare un cluster del servizio Azure Kubernetes privato.

Disponibilità della regione

L'integrazione rete virtuale del server API è attualmente disponibile in un subset di aree di Azure ed è soggetta a limiti di capacità a livello di area. Prima di iniziare, verificare che l'area di destinazione sia supportata. Per altre informazioni, vedere Integrazione rete virtuale del server API.

Prerequisiti

  • Versione minima dell'interfaccia della riga di comando di Azure 2.73.0. Verificare la versione usando il comando az --version. Per installare o aggiornare l'interfaccia della riga di comando di Azure, vedere Installare l'interfaccia della riga di comando di Azure.
  • Sono necessarie le autorizzazioni di Collaboratore e Collaboratore della rete sia per la sottoscrizione in cui viene distribuito il cluster AKS, sia per la sottoscrizione in cui si crea l'endpoint privato (se diversa). Questa operazione è necessaria per creare e gestire le risorse di rete necessarie, ad esempio subnet, servizio collegamento privato ed endpoint privato. Per altre informazioni, vedere Ruoli predefiniti del controllo degli accessi in base al ruolo di Azure.
  • Se si usano server DNS personalizzati, è necessario aggiungere l'INDIRIZZO IP virtuale di Azure 168.63.129.16 come server d'inoltro upstream.

Impostare le variabili di ambiente

  • Impostare le variabili di ambiente seguenti per l'uso in questo articolo. È possibile sostituire i valori segnaposto con i propri.

    LOCATION="westus3"

# Resource groups
AKS_RG="aks-demo-rg"
REMOTE_RG="client-demo-rg"

# AKS cluster VNet and subnets (all user-owned, in AKS_RG)
AKS_VNET="aks-vnet"
AKS_VNET_PREFIX="172.19.0.0/16"
APISERVER_SUBNET="apiserver-subnet"
APISERVER_SUBNET_PREFIX="172.19.0.0/28"
NODE_SUBNET="node-subnet"
NODE_SUBNET_PREFIX="172.19.1.0/24"

# Private Link Service subnet (also in the cluster VNet, user-owned)
PLS_SUBNET="pls-subnet"
PLS_SUBNET_PREFIX="172.19.2.0/24"

# AKS cluster
AKS_CLUSTER="aks-private"
AKS_IDENTITY="aks-identity"

# Private Link Service
PLS_NAME="apiserver-pls"

# Remote VNet
REMOTE_VNET="client-vnet"
REMOTE_SUBNET="client-subnet"
REMOTE_VNET_PREFIX="192.168.0.0/16"
REMOTE_SUBNET_PREFIX="192.168.1.0/24"
PE_NAME="aks-pe"
PE_CONN_NAME="aks-pe-conn"

# DNS
DNS_ZONE="private.${LOCATION}.azmk8s.io"
DNS_LINK="dns-link"

Creare gruppi di risorse

  1. Creare un gruppo di risorse per il cluster AKS usando il comando az group create.

    az group create --name $AKS_RG --location $LOCATION

  2. Creare un gruppo di risorse per la rete virtuale remota e l'endpoint privato usando il az group create comando . Può essere nella stessa sottoscrizione o in una diversa, ma deve trovarsi nella stessa regione

    az group create --name $REMOTE_RG --location $LOCATION

Creare la rete virtuale e le subnet del cluster

Con la rete virtuale BYO, è possibile creare e possedere la rete virtuale prima della distribuzione del cluster. In questo modo è possibile aggiungere risorse come la subnet PLS alla VNet senza toccare l'infrastruttura gestita da AKS.

Sono necessarie tre subnet:

Subnet Scopo Note
apiserver-subnet Inserimento del servizio di bilanciamento del carico interno del server API Deve essere delegato a Microsoft.ContainerService/managedClusters; minimo /28
node-subnet Nodi di lavoro AKS Subnet del cluster standard
pls-subnet Servizio Collegamento privato Deve avere criteri di rete del servizio collegamento privato disabilitati

  1. Creare la rete virtuale del cluster usando il az network vnet create comando .

    az network vnet create \
  --name $AKS_VNET \
  --resource-group $AKS_RG \
  --location $LOCATION \
  --address-prefixes $AKS_VNET_PREFIX

  2. Creare la subnet del server API delegata ad AKS usando il comando az network vnet subnet create. AKS inserisce il load balancer interno del piano di controllo in questa subnet, quindi è necessaria la delega a Microsoft.ContainerService/managedClusters.

    az network vnet subnet create \
  --name $APISERVER_SUBNET \
  --vnet-name $AKS_VNET \
  --resource-group $AKS_RG \
  --address-prefixes $APISERVER_SUBNET_PREFIX \
  --delegations Microsoft.ContainerService/managedClusters

  3. Creare la subnet del nodo usando il comando az network vnet subnet create.

    # Create the node subnet
az network vnet subnet create \
  --name $NODE_SUBNET \
  --vnet-name $AKS_VNET \
  --resource-group $AKS_RG \
  --address-prefixes $NODE_SUBNET_PREFIX

  4. Creare la subnet del Private Link Service con i criteri di rete disabilitati usando il comando az network vnet subnet create. I criteri di rete devono essere disabilitati nella subnet PLS per consentire al traffico dall'endpoint privato di raggiungere il servizio di bilanciamento del carico interno del server API.

    az network vnet subnet create \
  --name $PLS_SUBNET \
  --vnet-name $AKS_VNET \
  --resource-group $AKS_RG \
  --address-prefixes $PLS_SUBNET_PREFIX \
  --disable-private-link-service-network-policies

Creare un'identità gestita e assegnare autorizzazioni

AKS richiede un'identità gestita con diritti di Collaboratore della rete sia nella subnet del server API che nella subnet del nodo per gestire le risorse di rete durante le operazioni del cluster.

  1. Creare un'identità gestita di assegnazione utente per il cluster usando il az identity create comando .

    az identity create \
  --name $AKS_IDENTITY \
  --resource-group $AKS_RG \
  --location $LOCATION

  2. Ottenere l'ID risorsa dell'identità gestita usando il az identity show comando e impostarlo su una variabile di ambiente. Questo valore è necessario per assegnare l'identità al cluster.

    IDENTITY_ID=$(az identity show \
  --name $AKS_IDENTITY \
  --resource-group $AKS_RG \
  --query id -o tsv)

  3. Ottenere l'ID client dell'identità gestita usando il az identity show comando e impostarlo su una variabile di ambiente. Questo valore è necessario per assegnare ruoli nelle subnet.

    IDENTITY_CLIENT_ID=$(az identity show \
  --name $AKS_IDENTITY \
  --resource-group $AKS_RG \
  --query clientId -o tsv)

  4. Ottenere l'ID subnet del server API usando il az network vnet subnet show comando e impostarlo su una variabile di ambiente.

    APISERVER_SUBNET_ID=$(az network vnet subnet show \
  --name $APISERVER_SUBNET \
  --vnet-name $AKS_VNET \
  --resource-group $AKS_RG \
  --query id -o tsv)

  5. Ottenere l'ID subnet del nodo usando il az network vnet subnet show comando e impostarlo su una variabile di ambiente.

    NODE_SUBNET_ID=$(az network vnet subnet show \
  --name $NODE_SUBNET \
  --vnet-name $AKS_VNET \
  --resource-group $AKS_RG \
  --query id -o tsv)

  6. Assegnare il ruolo Collaboratore di rete alla subnet del server API usando il comando az role assignment create.

    az role assignment create \
  --scope $APISERVER_SUBNET_ID \
  --role "Network Contributor" \
  --assignee $IDENTITY_CLIENT_ID

  7. Assegnare il ruolo Collaboratore della rete alla subnet del nodo usando il comando az role assignment create.

    az role assignment create \
  --scope $NODE_SUBNET_ID \
  --role "Network Contributor" \
  --assignee $IDENTITY_CLIENT_ID

Distribuire un cluster privato con l'integrazione della rete virtuale del server API

  1. Creare il cluster privato AKS con integrazione VNet del server API usando il comando az aks create. È necessario specificare il flag --enable-apiserver-vnet-integration per abilitare la funzionalità e specificare gli ID della subnet del server API, della subnet del nodo e dell'identità gestita creati nei passaggi precedenti. AKS inserisce il load balancer interno del server API nella subnet del server API e distribuisce i nodi di lavoro nella subnet dei nodi.

    az aks create \
  --name $AKS_CLUSTER \
  --resource-group $AKS_RG \
  --location $LOCATION \
  --network-plugin azure \
  --enable-private-cluster \
  --enable-apiserver-vnet-integration \
  --vnet-subnet-id $NODE_SUBNET_ID \
  --apiserver-subnet-id $APISERVER_SUBNET_ID \
  --assign-identity $IDENTITY_ID \
  --generate-ssh-keys

  2. Al termine del provisioning del cluster, ottenere il gruppo di risorse del nodo in cui AKS distribuisce il load balancer interno kube-apiserver usando il comando az aks show e impostarlo su una variabile di ambiente.

    AKS_NODE_RG=$(az aks show \
  --name $AKS_CLUSTER \
  --resource-group $AKS_RG \
  --query nodeResourceGroup -o tsv)

  3. Ottenere l'etichetta FQDN privata per costruire il nome del record DNS in un secondo momento usando il az aks show comando e impostarla su una variabile di ambiente. Il nome di dominio completo privato è nel formato <label>.<region>.azmk8s.io, quindi è possibile estrarre l'etichetta dividendo sui punti.

    DNS_RECORD=$(az aks show \
  --name $AKS_CLUSTER \
  --resource-group $AKS_RG \
  --query privateFqdn -o tsv | cut -d'.' -f1,2)

  4. Ottenere l'ID di configurazione IP front-end del servizio di bilanciamento del carico interno del server API usando il az network lb show comando e impostarlo su una variabile di ambiente. Questo valore è necessario per far fronte al server API con il servizio collegamento privato.

    FRONTEND_IP_CONFIG_ID=$(az network lb show \
  --name kube-apiserver \
  --resource-group $AKS_NODE_RG \
  --query "frontendIPConfigurations[0].id" \
  -o tsv)

Poiché sei il proprietario della rete virtuale del cluster, puoi creare il PLS e la sua subnet direttamente in AKS_RG senza interagire con le risorse gestite da AKS. Puntare il PLS al front-end del load balancer interno kube-apiserver creato da AKS nel gruppo di risorse del nodo.

  • Creare il servizio collegamento privato nella rete virtuale del cluster usando il az network private-link-service create comando . Specificare la configurazione IP frontend del load balancer interno del kube-apiserver per presentare il server API con questo PLS.

    az network private-link-service create \
  --name $PLS_NAME \
  --resource-group $AKS_RG \
  --vnet-name $AKS_VNET \
  --subnet $PLS_SUBNET \
  --lb-frontend-ip-configs $FRONTEND_IP_CONFIG_ID \
  --location $LOCATION

Creare una rete virtuale remota e una subnet per l'endpoint privato

  1. Creare la rete virtuale remota usando il az network vnet create comando .

    az network vnet create \
  --name $REMOTE_VNET \
  --resource-group $REMOTE_RG \
  --location $LOCATION \
  --address-prefixes $REMOTE_VNET_PREFIX

  2. Creare la subnet remota usando il az network vnet subnet create comando .

    az network vnet subnet create \
  --name $REMOTE_SUBNET \
  --vnet-name $REMOTE_VNET \
  --resource-group $REMOTE_RG \
  --address-prefixes $REMOTE_SUBNET_PREFIX

Creare un endpoint privato nella rete virtuale remota

  1. Ottieni l'ID del servizio di collegamento privato per la connessione all'endpoint privato, utilizzando il comando az network private-link-service show e impostalo su una variabile di ambiente.

    PLS_ID=$(az network private-link-service show \
  --name $PLS_NAME \
  --resource-group $AKS_RG \
  --query id -o tsv)

  2. Creare il Private Endpoint nella rete virtuale remota e connetterlo al PLS nella rete virtuale del cluster usando il comando az network private-endpoint create. In questo modo viene stabilita la connessione privata tra la rete virtuale remota e il servizio di bilanciamento del carico interno del server API tramite PLS.

    az network private-endpoint create \
  --name $PE_NAME \
  --resource-group $REMOTE_RG \
  --vnet-name $REMOTE_VNET \
  --subnet $REMOTE_SUBNET \
  --private-connection-resource-id $PLS_ID \
  --connection-name $PE_CONN_NAME \
  --location $LOCATION

  3. Al termine del provisioning dell'endpoint privato, recuperare l'ID dell'interfaccia di rete usando il comando az network private-endpoint show e impostarlo su una variabile di ambiente. Questo valore è necessario per ottenere l'indirizzo IP privato assegnato all'endpoint privato, che viene usato per la configurazione DNS nel passaggio successivo.

    PE_NIC_ID=$(az network private-endpoint show \
  --name $PE_NAME \
  --resource-group $REMOTE_RG \
  --query 'networkInterfaces[0].id' \
  --output tsv)

  4. Ottieni l'indirizzo IP privato dell'endpoint privato dalla NIC usando il comando az network nic show e impostalo su una variabile di ambiente.

    PE_IP=$(az network nic show \
  --ids $PE_NIC_ID \
  --query 'ipConfigurations[0].privateIPAddress' \
  --output tsv)

Configurare il DNS privato

  1. Creare o riutilizzare una zona DNS privata nel gruppo di risorse remote usando il az network private-dns zone create comando . Il nome della zona DNS deve corrispondere al suffisso dell'FQDN privato del server API, che è nel formato <label>.<region>.azmk8s.io. In questo esempio viene usato private.<region>.azmk8s.io come nome della zona DNS.

    az network private-dns zone create \
  --name $DNS_ZONE \
  --resource-group $REMOTE_RG

  2. Creare un record A nella zona DNS per il nome di dominio completo privato del server API e indirizzarlo all'indirizzo IP dell'endpoint privato usando il az network private-dns record-set a create comando .

    az network private-dns record-set a create \
  --name $DNS_RECORD \
  --zone-name $DNS_ZONE \
  --resource-group $REMOTE_RG

  3. Aggiungere il record A che punta all'indirizzo IP dell'endpoint privato usando il comando az network private-dns record-set a add-record.

    az network private-dns record-set a add-record \
  --record-set-name $DNS_RECORD \
  --zone-name $DNS_ZONE \
  --resource-group $REMOTE_RG \
  --ipv4-address $PE_IP

  4. Collegare la zona DNS alla rete virtuale remota usando il az network private-dns link vnet create comando . Ciò consente alle risorse nella VNet remota di risolvere il FQDN privato del server API nell'indirizzo IP dell'endpoint privato.

    REMOTE_VNET_ID=$(az network vnet show \
  --name $REMOTE_VNET \
  --resource-group $REMOTE_RG \
  --query id -o tsv)

  5. Collegare la zona DNS al VNet remoto in modo che il FQDN privato venga risolto all'interno di quella rete usando il comando az network private-dns link vnet create.

    az network private-dns link vnet create \
  --name $DNS_LINK \
  --zone-name $DNS_ZONE \
  --resource-group $REMOTE_RG \
  --virtual-network $REMOTE_VNET_ID \
  --registration-enabled false

Testare la connessione

Annotazioni

Se si tenta di testare la connessione in locale, è possibile che venga visualizzato un errore perché la zona DNS non è collegata alla rete locale.

  1. Recupera le credenziali AKS usando il comando az aks get-credentials. Questo comando configura il contesto locale kubectl per la connessione al cluster. Se si esegue questo comando da un computer che non si trova nella rete virtuale remota, è possibile che venga visualizzato un errore perché il nome di dominio completo privato non viene risolto. Questo è previsto e conferma che il cluster non è accessibile dall'esterno della rete virtuale remota.

    az aks get-credentials --resource-group $AKS_RG --name $AKS_CLUSTER

  2. Controllare la connessione eseguendo un kubectl comando, ad esempio kubectl get nodes. Questo comando dovrebbe avere esito positivo se è in esecuzione da un computer con accesso di rete alla rete virtuale remota e la risoluzione DNS funziona correttamente. Se si esegue questo comando da un computer che non ha accesso alla rete virtuale remota, l'operazione dovrebbe non riuscire, confermando che il cluster è accessibile solo tramite l'endpoint privato.

    kubectl get nodes

Distribuire una macchina virtuale di test nella rete virtuale remota

Per confermare il percorso del Private Endpoint, distribuisci una macchina virtuale di test nella rete virtuale remota e utilizzala per connetterti al cluster AKS.

  1. Creare un gruppo di sicurezza di rete (NSG) che consenta il traffico SSH in ingresso sulla porta TCP 22 usando il az network nsg create comando .

    az network nsg create \
  --name "${REMOTE_VNET}-nsg" \
  --resource-group $REMOTE_RG \
  --location $LOCATION

  2. Aggiungere una regola NSG per consentire il traffico SSH in ingresso sulla porta TCP 22 usando il comando az network nsg rule create.

    az network nsg rule create \
  --nsg-name "${REMOTE_VNET}-nsg" \
  --resource-group $REMOTE_RG \
  --name allow-ssh \
  --priority 100 \
  --access Allow \
  --protocol Tcp \
  --direction Inbound \
  --source-address-prefixes '*' \
  --destination-port-ranges 22

  3. Associare l'NSG alla subnet remota usando il comando az network vnet subnet update.

    az network vnet subnet update \
  --name $REMOTE_SUBNET \
  --vnet-name $REMOTE_VNET \
  --resource-group $REMOTE_RG \
  --network-security-group "${REMOTE_VNET}-nsg"

  4. Creare una piccola macchina virtuale Ubuntu in tale subnet con un indirizzo IP pubblico per accedere rapidamente a SSH usando il az vm create comando .

    az vm create \
  --resource-group $REMOTE_RG \
  --name test-vm \
  --image Ubuntu2204 \
  --size Standard_B2s \
  --admin-username azureuser \
  --generate-ssh-keys \
  --vnet-name $REMOTE_VNET \
  --subnet $REMOTE_SUBNET \
  --public-ip-sku Standard

  5. Ottenere l'indirizzo IP pubblico della macchina virtuale usando il az vm show comando e impostarlo su una variabile di ambiente. Questo indirizzo IP è necessario per connettersi tramite SSH alla macchina virtuale per il test.

    VM_PUBLIC_IP=$(az vm show -d --resource-group $REMOTE_RG --name test-vm --query publicIps -o tsv)

Connettersi alla macchina virtuale e testare la connessione

  1. Eseguire SSH nella macchina virtuale usando l'indirizzo IP pubblico e la chiave privata generata durante la creazione della macchina virtuale. Il nome utente predefinito è azureuser a meno che non sia stato specificato un nome diverso durante la creazione della macchina virtuale.

    ssh -i ~/.ssh/id_rsa azureuser@$VM_PUBLIC_IP

  2. Dopo la connessione alla macchina virtuale, installare Azure CLI e kubectl per testare la connettività al cluster AKS tramite l'endpoint privato.

    curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

  3. Installare kubectl usando il comando Azure CLI.

    sudo az aks install-cli

  4. Esportare nuovamente le variabili del servizio Azure Kubernetes nell'ambiente della macchina virtuale in modo da poterle usare per ottenere le credenziali e testare la connessione.

    export AKS_RG="aks-demo-rg"
export AKS_CLUSTER="aks-private"

  5. Accedere ad Azure usando il az login comando . Questo comando richiede di eseguire l'autenticazione ed è possibile seguire le istruzioni per completare il processo di accesso.

    az login

  6. Ottieni le credenziali di AKS usando il comando az aks get-credentials. Questa configurazione consente di kubectl connettersi al cluster tramite l'endpoint privato.

    az aks get-credentials --resource-group $AKS_RG --name $AKS_CLUSTER

  7. Testare la connessione al cluster AKS eseguendo il comando kubectl, ad esempio kubectl get nodes. Se tutto è configurato correttamente, questo comando deve avere esito positivo e restituire l'elenco dei nodi nel cluster, confermando che è possibile accedere al server API privato tramite l'endpoint privato dalla rete virtuale remota.

    kubectl get nodes

  8. Dopo il test, è possibile uscire dalla sessione SSH nella macchina virtuale.

    exit

Pulire le risorse

  • Per evitare addebiti continui di Azure, eliminare i gruppi di risorse usando il az group delete comando . In questo modo vengono eliminate tutte le risorse contenute in tali gruppi, tra cui il cluster del servizio Azure Kubernetes, le reti virtuali, il servizio collegamento privato, l'endpoint privato e la zona DNS.

    az group delete --name $AKS_RG --yes --no-wait
az group delete --name $REMOTE_RG --yes --no-wait

Contenuti correlati

  • Last updated on