Configuración de servicios del tipo LoadBalancer para nodos híbridos - Amazon EKS
Equilibrador de carga de red de AWSEquilibrio de carga en el clúster de Cilium

Ayude a mejorar esta página

Para contribuir a esta guía del usuario, elija el enlace Edit this page on GitHub que se encuentra en el panel derecho de cada página.

Configuración de servicios del tipo LoadBalancer para nodos híbridos

En este tema se describe cómo configurar el equilibrio de carga de capa 4 (L4) para las aplicaciones que se ejecutan en Nodos híbridos de Amazon EKS. Los servicios de Kubernetes del tipo LoadBalancer se utilizan para exponer las aplicaciones de Kubernetes externas al clúster. Los servicios del tipo LoadBalancer se suelen utilizar con la infraestructura del equilibrador de carga físico en la nube o en un entorno en las instalaciones para atender el tráfico de la carga de trabajo. Esta infraestructura de equilibrador de carga suele aprovisionarse con un controlador específico del entorno.

AWS es compatible con Equilibradores de carga de red de AWS y Cilium para servicios del tipo LoadBalancer que se ejecutan en Nodos híbridos de EKS. La decisión de utilizar NLB o Cilium se basa en el origen del tráfico de aplicaciones. Si el tráfico de aplicaciones se origina en una región de AWS, AWS recomienda utilizar el NLB de AWS y el Controlador del equilibrador de carga de AWS. Si el tráfico de aplicaciones se origina en un entorno local en las instalaciones o en la periferia, AWS recomienda utilizar las funciones de equilibrio de carga integradas de Cilium, que se pueden utilizar con o sin una infraestructura de equilibradores de carga en su entorno.

Para obtener información sobre el equilibrio de carga de tráfico de aplicaciones de capa 7 (L7), consulte Configuración de Kubernetes Ingress para nodos híbridos. Para obtener información general sobre el equilibrio de carga con EKS, consulte las prácticas recomendadas para el equilibrio de carga.

Equilibrador de carga de red de AWS

Puede usar el Controlador del equilibrador de carga de AWS y el NLB con el tipo de destino ip para cargas de trabajo que se ejecutan en nodos híbridos. Cuando se utiliza el tipo de destino ip, el NLB reenvía el tráfico directamente a los pods, sin pasar por la ruta de red de la capa de servicio. Para que el NLB llegue a los destinos de IP de pods en nodos híbridos, los CIDR de pods en las instalaciones deben ser enrutables en la red en las instalaciones. Además, el Controlador del equilibrador de carga de AWS utiliza webhooks y requiere una comunicación directa desde el plano de control de EKS. Para obtener más información, consulte Configuración de webhooks para nodos híbridos.

Requisitos previos

Procedimiento

  1. Descargue una política de IAM para el Controlador del equilibrador de carga de AWS que le permita realizar llamadas a las API de AWS en su nombre.

    curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/refs/heads/main/docs/install/iam_policy.json

  2. Cree una política de IAM con la política descargada en el paso anterior.

    aws iam create-policy \
    --policy-name AWSLoadBalancerControllerIAMPolicy \
    --policy-document file://iam_policy.json

  3. Sustituya los valores del nombre del clúster (CLUSTER_NAME), la región de AWS (AWS_REGION) y el ID de la cuenta de AWS (AWS_ACCOUNT_ID) por su configuración y ejecute el siguiente comando.

    eksctl create iamserviceaccount \
    --cluster=CLUSTER_NAME \
    --namespace=kube-system \
    --name=aws-load-balancer-controller \
    --attach-policy-arn=arn:aws:iam::AWS_ACCOUNT_ID:policy/AWSLoadBalancerControllerIAMPolicy \
    --override-existing-serviceaccounts \
    --region AWS_REGION \
    --approve

  4. Agregue el repositorio de gráficos de Helm eks-charts. AWS mantiene este repositorio en GitHub.

    helm repo add eks https://aws.github.io/eks-charts

  5. Actualice el repositorio de Helm local para asegurarse de que cuenta con los gráficos más recientes.

    helm repo update eks

  6. Instale el Controlador del equilibrador de carga de AWS. Sustituya los valores del nombre del clúster (CLUSTER_NAME), la región de AWS (AWS_REGION), el ID de VPC (VPC_ID) y la versión del gráfico de Helm del Controlador del equilibrador de carga de AWS (AWS_LBC_HELM_VERSION) por su configuración. Para encontrar la versión más reciente del gráfico de Helm, ejecute helm search repo eks/aws-load-balancer-controller --versions. Si ejecuta un clúster en modo mixto con nodos híbridos y nodos en la nube de AWS, puede ejecutar el Controlador del equilibrador de carga de AWS en los nodos en la nube según las instrucciones de Controlador del equilibrador de carga de AWS.

    helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
  -n kube-system \
  --version AWS_LBC_HELM_VERSION \
  --set clusterName=CLUSTER_NAME \
  --set region=AWS_REGION \
  --set vpcId=VPC_ID \
  --set serviceAccount.create=false \
  --set serviceAccount.name=aws-load-balancer-controller

  7. Compruebe que el Controlador del equilibrador de carga de AWS se haya instalado correctamente.

    kubectl get -n kube-system deployment aws-load-balancer-controller
    NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   2/2     2            2           84s

  8. Defina una aplicación de ejemplo en un archivo denominado tcp-sample-app.yaml. El siguiente ejemplo usa una implementación simple de NGINX con un puerto TCP.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tcp-sample-app
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: public.ecr.aws/nginx/nginx:1.23
          ports:
            - name: tcp
              containerPort: 80

  9. Aplique la implementación al clúster.

    kubectl apply -f tcp-sample-app.yaml

  10. Defina un servicio del tipo LoadBalancer para la implementación en un archivo llamado tcp-sample-service.yaml.

    apiVersion: v1
kind: Service
metadata:
  name: tcp-sample-service
  namespace: default
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: external
    service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: LoadBalancer
  selector:
    app: nginx

  11. Aplique la configuración del servicio al clúster.

    kubectl apply -f tcp-sample-service.yaml

  12. El aprovisionamiento del NLB para el servicio puede tardar unos minutos. Una vez aprovisionado el NLB, el servicio tendrá asignada una dirección que se corresponderá con el nombre de DNS de la implementación del NLB.

    kubectl get svc tcp-sample-service
    NAME                 TYPE           CLUSTER-IP       EXTERNAL-IP                                                                    PORT(S)        AGE
tcp-sample-service   LoadBalancer   172.16.115.212   k8s-default-tcpsampl-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb.<region>.amazonaws.com   80:30396/TCP   8s

  13. Acceda al servicio con la dirección del NLB.

    curl k8s-default-tcpsampl-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb.<region>.amazonaws.com

    A continuación se muestra un ejemplo de salida.

    <!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
[...]

  14. Limpie los recursos de que ha creado.

    kubectl delete -f tcp-sample-service.yaml
kubectl delete -f tcp-sample-app.yaml

Equilibrio de carga en el clúster de Cilium

Cilium se puede utilizar como un equilibrador de cargas integrado en el clúster para las cargas de trabajo que se ejecutan en Nodos híbridos de EKS, lo que puede resultar útil para entornos que no tienen una infraestructura de equilibrador de carga. Las capacidades de equilibrio de carga de Cilium constan de una combinación de características de Cilium, que incluyen la sustitución de kube-proxy, Load Balancer IP Address Management (IPAM) y BGP Control Plane. Las responsabilidades de estas características se detallan a continuación:

  • Sustitución del kube-proxy de Cilium: gestiona el enrutamiento del tráfico del servicio a los pods de backend.

  • Cilium Load Balancer IPAM: administra las direcciones IP que se pueden asignar a servicios del tipo LoadBalancer.

  • Cilium BGP Control Plane: anuncia direcciones IP asignadas por Load Balancer IPAM a la red en las instalaciones.

Si no utiliza la sustitución de kube-proxy de Cilium, puede seguir utilizando Cilium Load Balancer IPAM y BGP Control Plane para asociar y asignar direcciones IP para los servicios del tipo LoadBalancer. Si no utilizas la sustitución de kube-proxy de Cilium, el equilibrio de carga para los servicios y los pods de backend se gestiona mediante reglas de kube-proxy e iptables de forma predeterminada en EKS.

Requisitos previos

  • Cilium se instala según las instrucciones de Configuración de una CNI para nodos híbridos con o sin la sustitución de kube-proxy activada. La sustitución de kube-proxy de Cilium requiere ejecutar un sistema operativo con un kernel de Linux al menos tan reciente como las versiones 4.19.57, 5.1.16 o 5.2.0. Todas las versiones recientes de los sistemas operativos compatibles para su uso con nodos híbridos cumplen estos requisitos, con la excepción de Red Hat Enterprise Linux (RHEL) 8.x.

  • Cilium BGP Control Plane está activado según las instrucciones de Configuración del BGP de Cilium para nodos híbridos. Si no desea usar el BGP, debe usar un método alternativo para que los CIDR de pods en las instalaciones sean enrutables dentro de la red en las instalaciones. Consulte CIDR de pod remoto enrutable para obtener más información.

  • Si tiene Helm instalado en su entorno de línea de comandos, consulte las instrucciones de configuración de Helm.

Procedimiento

  1. Cree un archivo llamado cilium-lbip-pool-loadbalancer.yaml con un recurso CiliumLoadBalancerIPPool para configurar el rango de direcciones IP del equilibrador de carga para los servicios del tipo LoadBalancer.

    • Reemplace LB_IP_CIDR por el rango de direcciones IP para utilizar las direcciones IP del equilibrador de carga. Para seleccionar una sola dirección IP, use un CIDR /32. Para obtener más información, consulte LoadBalancer IP Address Management en la documentación de Cilium.

    • El campo serviceSelector está configurado para que coincida con el nombre del servicio que creará en un paso posterior. Con esta configuración, las IP de este grupo solo se asignarán a los servicios con el nombre tcp-sample-service.

      apiVersion: cilium.io/v2alpha1
kind: CiliumLoadBalancerIPPool
metadata:
  name: tcp-service-pool
spec:
  blocks:
  - cidr: "LB_IP_CIDR"
  serviceSelector:
    matchLabels:
      io.kubernetes.service.name: tcp-sample-service

  2. Aplique el recurso CiliumLoadBalancerIPPool al clúster.

    kubectl apply -f cilium-lbip-pool-loadbalancer.yaml

  3. Confirme que haya al menos una dirección IP disponible en el grupo.

    kubectl get ciliumloadbalancerippools.cilium.io
    NAME               DISABLED   CONFLICTING   IPS AVAILABLE   AGE
tcp-service-pool   false      False         1               24m

  4. Cree un archivo llamado cilium-bgp-advertisement-loadbalancer.yaml con un recurso CiliumBGPAdvertisement para anunciar la dirección IP del equilibrador de carga para el servicio que creará en el siguiente paso. Si no utiliza el BGP de Cilium, puede saltarse este paso. La dirección IP del equilibrador de carga utilizada para el servicio debe poder enrutarse en la red en las instalaciones para que pueda consultar el servicio en el paso final.

    • El campo advertisementType está configurado como Service y service.addresses está configurado como LoadBalancerIP para anunciar solo LoadBalancerIP para los servicios del tipo LoadBalancer.

    • El campo selector está configurado para que coincida con el nombre del servicio que creará en un paso posterior. Con esta configuración, solo se anunciará LoadBalancerIP para servicios con el nombre tcp-sample-service.

      apiVersion: cilium.io/v2alpha1
kind: CiliumBGPAdvertisement
metadata:
  name: bgp-advertisement-tcp-service
  labels:
    advertise: bgp
spec:
  advertisements:
    - advertisementType: "Service"
      service:
        addresses:
          - LoadBalancerIP
      selector:
        matchLabels:
          io.kubernetes.service.name: tcp-sample-service

  5. Aplique el recurso CiliumBGPAdvertisement al clúster. Si no utiliza el BGP de Cilium, puede saltarse este paso.

    kubectl apply -f cilium-bgp-advertisement-loadbalancer.yaml

  6. Defina una aplicación de ejemplo en un archivo denominado tcp-sample-app.yaml. El siguiente ejemplo usa una implementación simple de NGINX con un puerto TCP.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tcp-sample-app
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: public.ecr.aws/nginx/nginx:1.23
          ports:
            - name: tcp
              containerPort: 80

  7. Aplique la implementación al clúster.

    kubectl apply -f tcp-sample-app.yaml

  8. Defina un servicio del tipo LoadBalancer para la implementación en un archivo llamado tcp-sample-service.yaml.

    • Puede solicitar una dirección IP específica del grupo de IP del equilibrador de carga con la anotación lbipam.cilium.io/ips en el objeto del servicio. Puede eliminar esta anotación si no desea solicitar una dirección IP específica para el servicio.

    • El campo de especificaciones loadBalancerClass es obligatorio para evitar que el proveedor de nube de AWS heredado cree un Equilibrador de carga clásico para el servicio. En el siguiente ejemplo, está configurado como io.cilium/bgp-control-plane para usar BGP Control Plane de Cilium como clase del equilibrador de carga. Como alternativa, este campo se puede configurar como io.cilium/l2-announcer para utilizar la característica L2 Announcements de Cilium (actualmente en versión beta y no compatible oficialmente con AWS).

      apiVersion: v1
kind: Service
metadata:
  name: tcp-sample-service
  namespace: default
  annotations:
    lbipam.cilium.io/ips: "LB_IP_ADDRESS"
spec:
  loadBalancerClass: io.cilium/bgp-control-plane
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: LoadBalancer
  selector:
    app: nginx

  9. Aplique el servicio al clúster. El servicio se creará con una dirección IP externa que podrá utilizar para acceder a la aplicación.

    kubectl apply -f tcp-sample-service.yaml

  10. Compruebe que el servicio se haya creado correctamente y que tenga asignada una IP diferente al CiliumLoadBalancerIPPool creado en el paso anterior.

    kubectl get svc tcp-sample-service
    NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
tcp-sample-service   LoadBalancer   172.16.117.76   LB_IP_ADDRESS   80:31129/TCP   14m

  11. Si utiliza Cilium en el modo de sustitución de kube-proxy, puede confirmar que Cilium se encarga del equilibrio de carga del servicio mediante la ejecución del siguiente comando. En el siguiente resultado, las direcciones 10.86.2.x son las direcciones IP de los pods de backend del servicio.

    kubectl -n kube-system exec ds/cilium -- cilium-dbg service list
    ID   Frontend               Service Type   Backend
...
41   LB_IP_ADDRESS:80/TCP   LoadBalancer   1 => 10.86.2.76:80/TCP (active)
                                           2 => 10.86.2.130:80/TCP (active)
                                           3 => 10.86.2.141:80/TCP (active)

  12. Confirme que Cilium anuncie la dirección IP en la red en las instalaciones mediante BGP. En el siguiente ejemplo, hay cinco nodos híbridos, cada uno de los cuales anuncia LB_IP_ADDRESS del servicio tcp-sample-service en la red en las instalaciones.

    Node                   VRouter      Prefix             NextHop   Age     Attrs
mi-026d6a261e355fba7   NODES_ASN
                  LB_IP_ADDRESS/32   0.0.0.0   12m3s   [{Origin: i} {Nexthop: 0.0.0.0}]
mi-082f73826a163626e   NODES_ASN
                  LB_IP_ADDRESS/32   0.0.0.0   12m3s   [{Origin: i} {Nexthop: 0.0.0.0}]
mi-09183e8a3d755abf6   NODES_ASN
                  LB_IP_ADDRESS/32   0.0.0.0   12m3s   [{Origin: i} {Nexthop: 0.0.0.0}]
mi-0d78d815980ed202d   NODES_ASN
                  LB_IP_ADDRESS/32   0.0.0.0   12m3s   [{Origin: i} {Nexthop: 0.0.0.0}]
mi-0daa253999fe92daa   NODES_ASN
                  LB_IP_ADDRESS/32   0.0.0.0   12m3s   [{Origin: i} {Nexthop: 0.0.0.0}]

  13. Acceda al servicio con la dirección IP del equilibrador de carga asignada.

    curl LB_IP_ADDRESS

    A continuación se muestra un ejemplo de salida.

    <!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
[...]

  14. Limpie los recursos de que ha creado.

    kubectl delete -f tcp-sample-service.yaml
kubectl delete -f tcp-sample-app.yaml
kubectl delete -f cilium-lb-ip-pool.yaml
kubectl delete -f cilium-bgp-advertisement.yaml