Uso de varios equilibradores de carga en Azure Kubernetes Service (versión preliminar)

Azure Kubernetes Service (AKS) normalmente aprovisiona un equilibrador de carga estándar (SLB) para todos los LoadBalancer servicios de un clúster. Dado que cada NIC de nodo está limitada a 300 reglas de equilibrio de carga de entrada y 8 servicios de vínculo privado, los clústeres grandes o las cargas de trabajo con gran carga de trabajo por puerto pueden agotar rápidamente estos límites.

La versión preliminar de varios SLB quita ese cuello de botella al permitirle crear varios SDB dentro del mismo clúster y nodos de partición y servicios en ellos. Las configuraciones del balanceador de carga se definen, cada una vinculada a un grupo de agentes principal y a un espacio de nombres, etiqueta o selectores de nodo opcionales, y AKS coloca automáticamente Nodos y Servicios en el SLB adecuado. El comportamiento de SNAT saliente no cambia si outboundType es loadBalancer. El tráfico saliente sigue fluyendo a través del primer SLB.

Utilice esta función para:

• Escale más allá de 300 reglas de entrada sin agregar clústeres.
• Aísle el tráfico de inquilino o carga de trabajo mediante el enlace de un SLB dedicado a su propio grupo de agentes.
• Distribuya servicios de vínculo privado entre varios SLAB al aproximarse al límite por SLB.

Prerrequisitos

• aks-preview extensión 18.0.0b1 o posterior.
• Marca de características Microsoft.ContainerService/MultipleStandardLoadBalancersPreview de suscripción registrada.
• Kubernetes versión 1.28 o posterior.
• Clúster creado con --load-balancer-backend-pool-type nodeIP o actualiza un clúster existente mediante az aks update.

Instalar la extensión aks-preview de la CLI de Azure

• Instale la extensión aks-preview mediante el comando az extension add.

  az extension add --name aks-preview
  

• Actualice a la última versión de la extensión publicada mediante el comando az extension update.

  az extension update --name aks-preview
  

Registro de la marca de característica MultipleStandardLoadBalancersPreview

1. Registre la marca de características de MultipleStandardLoadBalancersPreview mediante el comando az feature register.

   az feature register --namespace "Microsoft.ContainerService" --name "MultipleStandardLoadBalancersPreview"
   

   Tarda unos minutos en que el estado muestre Registrado.

2. Comprobar el estado del registro mediante el comando az feature show:

   az feature show --namespace "Microsoft.ContainerService" --name "MultipleStandardLoadBalancersPreview"
   

3. Cuando aparezca el estado Registrado, actualice el registro del proveedor de recursos Microsoft.ContainerService mediante el comando az provider register.

   az provider register --namespace Microsoft.ContainerService
   

Cómo elige AKS un equilibrador de carga (ubicación de nodo y servicio)

AKS usa varias entradas para determinar dónde colocar nodos y exponer LoadBalancer Services. Estas entradas se definen en cada configuración del equilibrador de carga e influyen en qué SLB se selecciona para cada recurso.

Cómo usa AKS estas entradas

El plano de control de AKS reconcilia continuamente el estado del nodo y el servicio mediante las reglas anteriores:

Ubicación del nodo

Cuando se agrega o actualiza un nodo, AKS comprueba los SLA que califica para según el grupo principal y el selector de nodos.

• Si coinciden varios SLBs, el controlador elige el que tiene menos nodos actuales.
• El nodo se agrega al grupo de back-end de SLB.

Ubicación del servicio

Cuando se crea o actualiza un servicio LoadBalancer:

1. AKS busca SLAB cuyo espacio de nombres y selectores de etiquetas coincidan con el servicio.
2. Si la anotación De servicio está presente, solo se tienen en cuenta los SLAB con nombre.
3. Se excluyen los SLA que tienen allowServicePlacement=false o que superarían los límites de Azure (300 reglas o 8 servicios de vínculo privado).
4. Entre las opciones válidas, se elige el SLB con las reglas más pocas.

comportamiento de externalTrafficPolicy (ETP)

AKS controla los servicios de forma diferente en función del valor de externalTrafficPolicy.

¿Por qué un grupo dedicado para ETP Local?
En el modo de varios SLB, los nodos que hospedan pods para un servicio determinado pueden residir en diferentes SLB de la VIP orientada al cliente. Un grupo de back-end compartido a menudo contendrá cero nodos aptos, lo que interrumpiría el tráfico. Al asignar un grupo por servicio y sincronizarlo desde EndpointSlice, AKS garantiza que el SLB del servicio apunte siempre a los nodos correctos.

Impacto en las cuotas

• Cada servicio local de ETP agrega un grupo de back-end y una regla de equilibrio de carga a su SLB.
• Estos cuentan hacia el límite de 300 reglas, por lo que se supervisa el uso de reglas cuando tiene muchos servicios locales de ETP.

No hay ningún cambio en el tráfico saliente

SNAT saliente continúa fluyendo a través del primer SLB aksOutboundBackendPool cuando outboundType es loadBalancer, sin importar la configuración de ETP.

Opcional: Reequilibrio

Puede reequilibrar manualmente la distribución de nodos más adelante mediante az aks loadbalancer rebalance.

Este diseño le permite definir el enrutamiento flexible controlado por etiquetas para la infraestructura y las cargas de trabajo, mientras que AKS controla la ubicación automáticamente para mantener el equilibrio y evitar problemas de cuota.

Adición de la primera configuración del equilibrador de carga

Agregue una configuración denominada kubernetes y enlazarla a un grupo de agentes principal que siempre tenga al menos un nodo. Al quitar todas las configuraciones, el clúster vuelve a cambiar al modo de un solo SLB.

1. Establezca variables de entorno para usarlas en este tutorial. Puede reemplazar todos los valores de marcador de posición por sus propios, excepto DEFAULT_LB_NAME, que deben permanecer como kubernetes.

   RESOURCE_GROUP="rg-aks-multislb"
   CLUSTER_NAME="aks-multi-slb"
   LOCATION="westus"
   DEFAULT_LB_NAME="kubernetes"
   PRIMARY_POOL="nodepool1"
   

2. Cree un grupo de recursos mediante el az group create comando .

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

3. Cree un clúster de AKS mediante el az aks create comando .\

   az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME \
     --load-balancer-backend-pool-type nodeIP \
     --node-count 3
   

4. Agregue un equilibrador de carga predeterminado mediante el az aks loadbalancer add comando .

   az aks loadbalancer add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $DEFAULT_LB_NAME \
     --primary-agent-pool-name $PRIMARY_POOL \
     --allow-service-placement true
   

Adición de equilibradores de carga adicionales

Cree configuraciones específicas del cliente especificando un grupo principal diferente, junto con un espacio de nombres, una etiqueta o selectores de nodos opcionales.

1. El equipo 1 ejecutará sus propias cargas de trabajo en un grupo de nodos independiente. Asigne una tenant=team1 etiqueta para que las cargas de trabajo se puedan programar mediante selectores:

   TEAM1_POOL="team1pool"
   TEAM1_LB_NAME="team1-lb"
   

2. Cree un segundo grupo de nodos para el equipo 1 mediante el az aks nodepool add comando .

   az aks nodepool add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $TEAM1_POOL \
     --labels tenant=team1 \
     --node-count 2
   

3. Cree un equilibrador de carga para el equipo 1 mediante el az aks loadbalancer add comando .

   az aks loadbalancer add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $TEAM1_LB_NAME \
     --primary-agent-pool-name $TEAM1_POOL \
     --service-namespace-selector "tenant=team1" \
     --node-selector "tenant=team1"
   

4. Etiquete el espacio de nombres de destino (por ejemplo, team1-apps) para que coincida con el selector mediante el comando az aks command invoke.

   az aks command invoke \
     --resource-group $RESOURCE_GROUP \
     --name $CLUSTER_NAME \
     --command "
   kubectl create namespace team1-apps --dry-run=client -o yaml | kubectl apply -f -
   kubectl label namespace team1-apps tenant=team1 --overwrite
   "
   

5. Ahora puede enumerar los equilibradores de carga del clúster para ver las varias configuraciones mediante el az aks loadbalancer list comando .

   az aks loadbalancer list --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --output table
   

   Ejemplo de resultado:

   AllowServicePlacement    ETag     Name        PrimaryAgentPoolName    ProvisioningState    ResourceGroup
   -----------------------  -------  ----------  ----------------------  -------------------  ---------------
   True                     <ETAG>   kubernetes  nodepool1               Succeeded            rg-aks-multislb
   True                     <ETAG>   team1-lb    team1pool               Succeeded            rg-aks-multislb
   

Implementación de un servicio en un equilibrador de carga específico

Agregue la anotación con una lista separada por comas service.beta.kubernetes.io/azure-load-balancer-configurations de nombres de configuración. Si se omite la anotación, el controlador elige automáticamente.

az aks command invoke \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --command "
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: lb-svc-1
  namespace: team1-apps
  labels:
    app: nginx-test
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-configurations: \"team1-lb\"
    # service.beta.kubernetes.io/azure-load-balancer-internal: "true" # If you want to create an internal load balancer. 
spec:
  selector:
    app: nginx-test
  ports:
  - name: port1
    port: 80
    targetPort: 80
    protocol: TCP
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-test
  namespace: team1-apps
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-test
  template:
    metadata:
      labels:
        app: nginx-test
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
        resources:
          limits:
            cpu: \"150m\"
            memory: \"300Mi\"
EOF
"

Reequilibrar nodos (opcional)

Ejecute una operación de reequilibrio después de escalar si los recuentos de reglas se desequilibran mediante el az aks loadbalancer rebalance comando . Este comando interrumpe los flujos activos, por lo que lo programa durante una ventana de mantenimiento.

az aks loadbalancer rebalance --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME

Supervisión y solución de problemas

• Observe los eventos del controlador (kubectl get events …) para confirmar que los servicios se reconcilian.
• Si la conectividad externa está bloqueada, abra un shell de nodo y active la VIP de servicio para confirmar el enrutamiento del proxy kube.

Limitaciones y problemas conocidos

Limpieza de recursos

Elimine el grupo de recursos cuando haya terminado de quitar el clúster y los equilibradores de carga mediante el az group delete comando .

az group delete --name $RESOURCE_GROUP --yes --no-wait

Pasos siguientes

La característica de varios SLB ayuda a escalar y aislar las cargas de trabajo en la capa de red, a la vez que mantiene la simplicidad a través de la configuración administrada por Azure. Para obtener más información, consulte los siguientes recursos:

• Conceptos del equilibrador de carga de AKS
• Configuración de conexiones salientes en AKS
• Grupos de nodos de AKS
• Límites de la suscripción de Azure