Conexión a un clúster de integración con red virtual del servidor de API mediante Azure Private Link

Con la integración con red virtual del servidor de API, se puede acceder al plano de control de AKS a través de una dirección IP privada dentro de la red virtual (VNet) del clúster. Esta configuración funciona bien para las cargas de trabajo que se ejecutan en la misma red virtual, pero no cubre automáticamente redes externas, como una red central, una red virtual de operaciones dedicadas o un entorno de jump-host que necesite acceder al servidor de API sin exponerlo a la red pública de Internet. En este artículo se muestra cómo puentear esa brecha poniendo un servicio Private Link delante del servidor API y, a continuación, conectarse a él desde una red virtual independiente a través de un Punto de Conexión Privado.

Este artículo solo se aplica a los clústeres de AKS privados que se crean con la integración con red virtual del servidor de API y que usen una configuración personalizada y propia de red virtual (BYO VNet). Aprenderá a:

  • Implemente un clúster de AKS privado con integración con red virtual del servidor de API mediante su propia red virtual.
  • Exponga el servidor de API a través de un servicio Private Link (PLS) dentro de la red virtual del clúster.
  • Cree un punto de conexión privado (PE) en una red virtual diferente.
  • Configure DNS privado para que las herramientas de Kubernetes resuelvan el FQDN privado del clúster dentro de la red remota.

Para los clústeres privados que no usan la integración con red virtual del servidor de API, consulte Creación de un clúster de AKS privado.

Disponibilidad en regiones

La integración con red virtual del servidor de API está disponible actualmente en un subconjunto de regiones de Azure y está sujeta a límites de capacidad regionales. Antes de comenzar, verifique que la región de destino está admitida. Para más información, consulte Integración con red virtual del servidor de API.

Prerrequisitos

  • Versión mínima de la CLI de Azure 2.73.0. Compruebe la versión con el comando az --version. Para instalar o actualizar la CLI de Azure, consulte Instalación de la CLI de Azure.
  • Necesita permisos de "Colaborador" y "Colaborador de red" tanto en la suscripción en la cual se despliega el clúster AKS, como en la suscripción en la que se crea el punto de conexión privado (si es diferente). Esto es necesario para crear y administrar los recursos de red necesarios, como subredes, servicio Private Link y punto de conexión privado. Para obtener más información, consulte los roles integrados de control de acceso basado en roles (RBAC) de Azure.
  • Si usa servidores DNS personalizados, debe agregar la dirección IP virtual de Azure , 168.63.129.16, como reenviador ascendente.

Establecimiento de variables de entorno

  • Establezca las siguientes variables de entorno para usarlas en este artículo. No dude en reemplazar los valores de marcador de posición por los suyos propios.

    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"

Crear grupos de recursos

  1. Cree un grupo de recursos para el clúster de AKS mediante el az group create comando .

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

  2. Cree un grupo de recursos para la red virtual remota y el punto de conexión privado mediante el az group create comando . Puede estar en la misma suscripción o en otra diferente, pero debe estar en la misma región.

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

Creación de la red virtual del clúster y las subredes

Con la red virtual BYO, puede crear y poseer la red virtual antes de implementar el clúster. Esto le permite agregar recursos como la subred PLS a la red virtual sin tocar la infraestructura administrada por AKS.

Se requieren tres subredes:

Subred propósito Notas
apiserver-subnet Inserción del equilibrador de carga interno del servidor de API Debe delegarse en Microsoft.ContainerService/managedClusters; mínimo /28
node-subnet Nodos de trabajo de AKS Subred de clúster estándar
pls-subnet Servicio Private Link Debe tener deshabilitadas las directivas de red del servicio Private Link

  1. Cree la red virtual del clúster mediante el az network vnet create comando .

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

  2. Cree la subred del servidor de API delegada a AKS con el comando az network vnet subnet create. AKS inserta el equilibrador de carga interno del plano de control en esta subred, para lo que se necesita la delegación en 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. Cree la subred del nodo mediante el az network vnet subnet create comando .

    # 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. Cree la subred del servicio Private Link con directivas de red deshabilitadas mediante el az network vnet subnet create comando . Las directivas de red deben deshabilitarse en la subred PLS para permitir que el tráfico desde el punto de conexión privado llegue al equilibrador de carga interno del servidor de 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

Creación de una identidad administrada y asignación de permisos

AKS requiere una identidad administrada con derechos de colaborador de red tanto en la subred del servidor de API como en la subred del nodo para administrar los recursos de red durante las operaciones del clúster.

  1. Cree una identidad administrada de asignación de usuario para el clúster mediante el az identity create comando .

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

  2. Obtenga el identificador de recurso de la identidad administrada mediante el az identity show comando y establézcalo en una variable de entorno. Necesita este valor para asignar la identidad al clúster.

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

  3. Obtenga el identificador de cliente de la identidad administrada mediante el az identity show comando y establézcalo en una variable de entorno. Usted necesita este valor para asignar roles en las subredes.

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

  4. Obtenga el identificador de subred del servidor de API mediante el az network vnet subnet show comando y establézcalo en una variable de entorno.

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

  5. Obtenga el identificador de subred del nodo mediante el az network vnet subnet show comando y establézcalo en una variable de entorno.

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

  6. Asigne el rol Colaborador de red a la subred del servidor de API mediante el comando az role assignment create.

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

  7. Asigne el rol Colaborador de red a la subred del nodo mediante el az role assignment create comando .

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

Implementación de un clúster privado con integración con red virtual de API Server

  1. Cree el clúster de AKS privado con la integración con red virtual del servidor de API mediante el comando az aks create. Debe especificar la bandera --enable-apiserver-vnet-integration para habilitar la funcionalidad y proporcionar los identificadores de la subred del servidor de API, la subred del nodo y la identidad administrada que creó en los pasos previos. AKS inserta el equilibrador de carga interno del servidor de API en la subred del servidor de API e implementa nodos de trabajo en la subred del nodo.

    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. Cuando el clúster termine de aprovisionar, obtenga el grupo de recursos del nodo donde AKS implementa el equilibrador de carga interno kube-apiserver mediante el az aks show comando y establézcalo en una variable de entorno.

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

  3. Obtenga la etiqueta FQDN privada para construir el nombre del registro DNS más adelante mediante el az aks show comando y establézcalo en una variable de entorno. El FQDN privado tiene el formato <label>.<region>.azmk8s.io, por lo que puede extraer la etiqueta separándola por los puntos.

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

  4. Obtenga el identificador de configuración de IP de front-end del equilibrador de carga interno del servidor de API mediante el az network lb show comando y establézcalo en una variable de entorno. Necesita este valor para que el servicio Private Link actúe como intermediario del servidor de API.

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

Dado que posee la red virtual del clúster, puede crear el PLS y su subred directamente en AKS_RG sin interactuar con los recursos administrados por AKS. Apunte el PLS al front-end kube-apiserver del equilibrador de carga interno que AKS creó en el grupo de recursos del nodo.

  • Cree el servicio Private Link en la red virtual del clúster mediante el az network private-link-service create comando . Indique la configuración IP de front-end del equilibrador de carga interno kube-apiserver para dirigir el tráfico al servidor de API a través del 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

Creación de una red virtual remota y una subred para el punto de conexión privado

  1. Cree la red virtual remota mediante el az network vnet create comando .

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

  2. Cree la subred remota mediante el 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

Creación de un punto de conexión privado en la red virtual remota

  1. Obtenga el ID de Private Link Service para conectar el punto de conexión privado mediante el comando az network private-link-service show y cámbielo a una variable de entorno.

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

  2. Cree el punto de conexión privado en la red virtual remota y conéctelo a PLS en la red virtual del clúster mediante el az network private-endpoint create comando . Esto establece la conexión privada entre la red virtual remota y el equilibrador de carga interno del servidor de API a través del 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. Cuando el punto de conexión privado termine de aprovisionar, obtenga el identificador de la interfaz de red (NIC) mediante el az network private-endpoint show comando y establézcalo en una variable de entorno. Necesita este valor para obtener la dirección IP privada asignada al punto de conexión privado, que se usa para la configuración de DNS en el paso siguiente.

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

  4. Obtenga la dirección IP privada del punto de conexión privado de la NIC mediante el az network nic show comando y establézcala en una variable de entorno.

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

Configuración de DNS privado

  1. Cree o reutilice una zona DNS privada en el grupo de recursos remoto mediante el az network private-dns zone create comando . El nombre de la zona DNS debe coincidir con el sufijo del FQDN privado del servidor de API, que tiene el formato <label>.<region>.azmk8s.io. En este ejemplo, se usa private.<region>.azmk8s.io como nombre de zona DNS.

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

  2. Cree un registro A en la zona DNS para el FQDN privado del servidor de API y apunte a la dirección IP del punto de conexión privado utilizando el comando az network private-dns record-set a create.

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

  3. Agregue el registro A que apunta a la dirección IP del punto de conexión privado mediante el az network private-dns record-set a add-record comando .

    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. Vincule la zona DNS a la red virtual remota mediante el az network private-dns link vnet create comando . Esto permite que los recursos de la red virtual remota resuelvan el FQDN privado del servidor de API en la dirección IP del punto de conexión privado.

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

  5. Vincule la zona DNS a la red virtual remota para que el FQDN privado se resuelva dentro de esa red mediante el az network private-dns link vnet create comando .

    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

Comprobación de la conexión

Nota:

Si intenta probar la conexión localmente, es posible que reciba un error porque la zona DNS no está vinculada a la red local.

  1. Obtenga las credenciales de AKS mediante el az aks get-credentials comando . Este comando configura el contexto local kubectl para conectarse al clúster. Si ejecuta este comando desde una máquina que no está en la red virtual remota, es posible que reciba un error porque el FQDN privado no se resuelve. Esto se espera y confirma que el clúster no es accesible desde fuera de la red virtual remota.

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

  2. Compruebe la conexión mediante la ejecución de un kubectl comando, como kubectl get nodes. Este comando debe realizarse correctamente si lo ejecuta desde una máquina que tiene acceso de red a la red virtual remota y la resolución DNS funciona correctamente. Si ejecuta este comando desde una máquina que no tiene acceso a la red virtual remota, debería producir un error y confirmar que el clúster solo es accesible a través del punto de conexión privado.

    kubectl get nodes

Implementación de una máquina virtual de prueba en la red virtual remota

Para confirmar la ruta de acceso del punto de conexión privado, implemente una máquina virtual de prueba en la red virtual remota y úsela para conectarse al clúster de AKS.

  1. Cree un grupo de seguridad de red (NSG) que permita el tráfico SSH entrante en el puerto TCP 22 mediante el az network nsg create comando .

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

  2. Agregue una regla de NSG para permitir el tráfico SSH entrante en el puerto TCP 22 mediante el az network nsg rule create comando .

    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. Asocie el NSG a la subred remota mediante el 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. Cree una máquina virtual Ubuntu pequeña en esa subred con una dirección IP pública para el acceso SSH rápido mediante el 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. Obtenga la dirección IP pública de la máquina virtual mediante el az vm show comando y establézcala en una variable de entorno. Necesita esta dirección IP para conectarse mediante SSH a la máquina virtual para realizar pruebas.

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

Conexión a la máquina virtual y prueba de la conexión

  1. SSH en la VM usando la dirección IP pública y la clave privada que generó al crear la VM. El nombre de usuario predeterminado es azureuser a menos que haya especificado otro durante la creación de la máquina virtual.

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

  2. Una vez conectado a la máquina virtual, instale la CLI de Azure y kubectl para probar la conectividad con el clúster de AKS a través del punto de conexión privado.

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

  3. Instale kubectl mediante el comando de la CLI de Azure.

    sudo az aks install-cli

  4. Vuelva a exportar las variables de AKS en el entorno de máquina virtual para poder usarlas para obtener credenciales y probar la conexión.

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

  5. Inicie sesión en Azure con el az login comando . Este comando le pide que se autentique y puede seguir las instrucciones para completar el proceso de inicio de sesión.

    az login

  6. Obtenga las credenciales de AKS mediante el az aks get-credentials comando . Esto configura kubectl para conectarse al clúster a través del punto de conexión privado.

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

  7. Pruebe la conexión al clúster de AKS mediante la ejecución de un kubectl comando, como kubectl get nodes. Si todo está configurado correctamente, este comando debe realizarse correctamente y devolver la lista de nodos del clúster, confirmando que puede acceder al servidor de API privado a través del punto de conexión privado desde la red virtual remota.

    kubectl get nodes

  8. Después de realizar las pruebas, puede salir de la sesión SSH en la máquina virtual.

    exit

Limpieza de recursos

  • Para evitar cargos continuos de Azure, elimine los grupos de recursos mediante el az group delete comando . Esto elimina todos los recursos contenidos en esos grupos, incluidos el clúster de AKS, las redes virtuales, el servicio Private Link, el punto de conexión privado y la zona DNS.

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

Contenido relacionado

  • Last updated on