**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](hybrid-nodes-ingress.md). Para obtener información general sobre el equilibrio de carga con EKS, consulte las [prácticas recomendadas para el equilibrio de carga](https://docs.aws.amazon.com/eks/latest/best-practices/load-balancing.html). ## Equilibrador de carga de red de AWS Puede usar el [Controlador del equilibrador de carga de AWS](aws-load-balancer-controller.md) 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](hybrid-nodes-webhooks.md). + Consulte [Dirija el tráfico de TCP y UDP con equilibradores de carga de red](network-load-balancing.md) para ver los requisitos de configuración de la subred, así como [Instalación del Controlador del equilibrador de carga de AWS con Helm](lbc-helm.md) y [Best Practices for Load Balancing](https://docs.aws.amazon.com/eks/latest/best-practices/load-balancing.html) para obtener información adicional sobre el Equilibrador de carga de red de AWS y el Controlador del equilibrador de carga de AWS. + Consulte [AWS Load Balancer Controller NLB configurations](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/nlb/) para obtener configuraciones que se pueden aplicar a servicios del tipo `LoadBalancer` con el Equilibrador de carga de red de AWS. ### Requisitos previos + Se instaló Cilium según las instrucciones de [Configuración de una CNI para nodos híbridos](hybrid-nodes-cni.md). + Cilium BGP Control Plane está activado según las instrucciones de [Configuración del BGP de Cilium para nodos híbridos](hybrid-nodes-cilium-bgp.md). 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](hybrid-nodes-concepts-kubernetes.md#hybrid-nodes-concepts-k8s-pod-cidrs) 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](helm.md). + Si tiene eksctl instalado en su entorno de línea de comandos, consulte las [instrucciones de configuración de eksctl](install-kubectl.md#eksctl-install-update). ### 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 ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. Actualice el repositorio de Helm local para asegurarse de que cuenta con los gráficos más recientes. ``` helm repo update eks ``` 1. 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](hybrid-nodes-webhooks.md#hybrid-nodes-mixed-lbc). ``` 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 ``` 1. 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 ``` 1. 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 ``` 1. Aplique la implementación al clúster. ``` kubectl apply -f tcp-sample-app.yaml ``` 1. 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 ``` 1. Aplique la configuración del servicio al clúster. ``` kubectl apply -f tcp-sample-service.yaml ``` 1. 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..amazonaws.com 80:30396/TCP 8s ``` 1. Acceda al servicio con la dirección del NLB. ``` curl k8s-default-tcpsampl-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb..amazonaws.com ``` A continuación se muestra un ejemplo de salida. ``` Welcome to nginx! [...] ``` 1. 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](hybrid-nodes-cni.md) 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](hybrid-nodes-cilium-bgp.md). 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](hybrid-nodes-concepts-kubernetes.md#hybrid-nodes-concepts-k8s-pod-cidrs) 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](helm.md). ### 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](https://docs.cilium.io/en/stable/network/lb-ipam/) 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 ``` 1. Aplique el recurso `CiliumLoadBalancerIPPool` al clúster. ``` kubectl apply -f cilium-lbip-pool-loadbalancer.yaml ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. Aplique la implementación al clúster. ``` kubectl apply -f tcp-sample-app.yaml ``` 1. 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](https://docs.cilium.io/en/latest/network/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 ``` 1. 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 ``` 1. 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 ``` 1. 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) ``` 1. 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}] ``` 1. 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. ``` Welcome to nginx! [...] ``` 1. 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 ```