Configurar serviços do tipo LoadBalancer para nós híbridos - Amazon EKS
AWS Network Load BalancerBalanceamento de carga no cluster do Cilium

Ajudar a melhorar esta página

Para contribuir com este guia de usuário, escolha o link Editar esta página no GitHub, disponível no painel direito de cada página.

Configurar serviços do tipo LoadBalancer para nós híbridos

Este tópico descreve como configurar o balanceamento de carga de camada 4 (L4) para aplicações executadas no Amazon EKS Hybrid Nodes. Os serviços Kubernetes do tipo LoadBalancer são usados para expor aplicações do Kubernetes externos ao cluster. Serviços do tipo LoadBalancer são comumente usados com a infraestrutura física do balanceador de carga na nuvem ou no ambiente on-premises para atender ao tráfego da workload. Essa infraestrutura de balanceador de carga geralmente é provisionada com um controlador específico do ambiente.

A AWS oferece suporte para o AWS Network Load Balancer (NLB) e o Cilium para serviços do tipo LoadBalancer em execução no EKS Hybrid Nodes. A decisão de usar o NLB ou o Cilium é baseada na origem do tráfego da aplicação. Se o tráfego da aplicação for originário de uma região da AWS, a AWS recomenda usar o AWS NLB e o AWS Load Balancer Controller. Se o tráfego da aplicação for originado do ambiente on-premises ou de borda, a AWS recomenda usar os recursos de balanceamento de carga integrados do Cilium, que podem ser usados com ou sem a infraestrutura de balanceador de carga em seu ambiente.

Para balanceamento de carga de tráfego de aplicações de camada 7 (L7), consulte Configurar o Ingress do Kubernetes para nós híbridos. Para obter informações gerais sobre balanceamento de carga com EKS, consulte Melhores práticas para balanceamento de carga.

AWS Network Load Balancer

Você pode usar o AWS Load Balancer Controller e o NLB com o tipo de destino ip para workloads executadas em nós híbridos. Ao usar o tipo de destino ip, o NLB encaminha o tráfego diretamente para os pods, ignorando o caminho de rede da camada de serviço. Para que o NLB alcance as metas de IP do pod em nós híbridos, os CIDRs de pods on-premises deverão ser roteáveis em sua rede on-premises roteáveis em sua rede on-premises roteáveis. Além disso, o AWS Load Balancer Controller usa webhooks e requer comunicação direta do ambiente de gerenciamento EKS. Para obter mais informações, consulte Configurar webhooks para nós híbridos.

Pré-requisitos

Procedimento

  1. Baixe uma política do IAM para o AWS Load Balancer Controller que permita que ele faça chamadas para APIs da AWS em seu nome.

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

  2. Crie uma política do IAM usando a política obtida por download na etapa anterior.

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

  3. Substitua os valores do nome do cluster (CLUSTER_NAME), região da AWS (AWS_REGION) e ID da conta da AWS (AWS_ACCOUNT_ID) pelas suas configurações e execute o comando a seguir.

    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. Adicione o repositório de chart do Helm eks-charts. A AWS mantém esse repositório no GitHub.

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

  5. Atualize o repositório local do Helm para confirmar que você tem os gráficos mais recentes.

    helm repo update eks

  6. Instale o AWS Load Balancer Controller. Substitua os valores do nome do cluster (CLUSTER_NAME), região da AWS (AWS_REGION), ID da VPC (VPC_ID) e a versão do chart do Helm do AWS Load Balancer Controller (AWS_LBC_HELM_VERSION) pelas suas configurações. Você pode encontrar a versão mais recente do chart do Helm executando helm search repo eks/aws-load-balancer-controller --versions. Se você estiver executando um cluster em modo misto com nós híbridos e nós na Nuvem AWS, você pode executar o AWS Load Balancer Controller nos nós da nuvem seguindo as instruções em AWS Load Balancer Controller.

    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. Verifique se o AWS Load Balancer Controller foi instalado com êxito.

    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 uma aplicação de amostra em um arquivo chamado tcp-sample-app.yaml. O exemplo abaixo usa uma implantação simples do NGINX com uma porta 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 a implantação ao seu cluster.

    kubectl apply -f tcp-sample-app.yaml

  10. Defina um serviço do tipo LoadBalancer para a implantação em um arquivo chamado 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. Aplicar a configuração do serviço ao seu cluster.

    kubectl apply -f tcp-sample-service.yaml

  12. O provisionamento do NLB para o serviço pode levar alguns minutos. Depois que o NLB for provisionado, o serviço terá um endereço atribuído a ele que corresponde ao nome DNS da implantação do 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. Acesse o serviço usando o endereço do NLB.

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

    Um exemplo de saída está abaixo.

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

  14. Limpe os recursos que você criou.

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

Balanceamento de carga no cluster do Cilium

O Cilium pode ser usado como um balanceador de carga no cluster para workloads em execução no EKS Hybrid Nodes, o que pode ser útil para ambientes que não têm infraestrutura de balanceador de carga. Os recursos de balanceamento de carga do Cilium são baseados em uma combinação de atributos do Cilium, incluindo a substituição do kube-proxy, o Gerenciador de endereços IP (IPAM) do balanceador de carga e o ambiente de gerenciamento BGP. As responsabilidades desses atributos estão detalhadas abaixo:

  • Substituição do Cilium kube-proxy: manipula o tráfego do serviço de roteamento para pods de backend.

  • IPAM do Cilium Load Balancer: gerencia endereços IP que podem ser atribuídos a serviços do tipo LoadBalancer.

  • Ambiente de gerenciamento do Cilium BGP: anuncia endereços IP alocados para IPAM do balanceador de carga para a rede on-premises.

Se você não estiver usando o substituto kube-proxy do Cilium, ainda poderá usar o IPAM do balanceador de carga do Cilium e o ambiente de gerenciamento do BGP para alocar e atribuir endereços IP para serviços do tipo LoadBalancer. Se você não estiver usando o substituto kube-proxy do Cilium, o balanceamento de carga dos serviços para pods de backend é feito pelas regras kube-proxy e iptables por padrão no EKS.

Pré-requisitos

  • O Cilium foi instalado seguindo as instruções Configurar a CNI para nós híbridos com ou sem a substituição do kube-proxy ativada. A substituição do kube-proxy do Cilium requer a execução de um sistema operacional com um kernel Linux pelo menos tão recente quanto v4.19.57, v5.1.16 ou v5.2.0. Todas as versões recentes dos sistemas operacionais compatíveis para uso com nós híbridos atendem a esses critérios, com exceção do Red Hat Enterprise Linux (RHEL) 8.x.

  • O ambiente de gerenciamento BGP do Cilium é habilitado seguindo as instruções em Configurar o BGP do Cilium para nós híbridos. Se não quiser usar o BGP, você deverá usar um método alternativo para tornar seus CIDRs de pods on-premises roteáveis em sua rede on-premises. Consulte CIDRs de pods remotos roteáveis para obter mais informações.

  • O Helm foi instalado em seu ambiente de linha de comando. Consulte as Instruções de configuração do Helm.

Procedimento

  1. Crie um arquivo chamado cilium-lbip-pool-loadbalancer.yaml com um recurso CiliumLoadBalancerIPPool para configurar o intervalo de endereços IP do balanceador de carga para seus serviços do tipo LoadBalancer.

    • Substitua LB_IP_CIDR pelo intervalo de endereços IP a ser usado para os endereços IP do balanceador de carga. Para selecionar um único endereço IP, use um /32 CIDR. Para obter mais informações, consulte Gerenciamento de endereços IP do LoadBalancer na documentação do Cilium.

    • O campo serviceSelector está configurado para corresponder ao nome do serviço que você criará em uma etapa subsequente. Com essa configuração, os IPs desse pool serão alocados somente aos serviços com o nome 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 o recurso CiliumLoadBalancerIPPool ao seu cluster.

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

  3. Confirme se há pelo menos um endereço IP disponível no pool.

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

  4. Crie um arquivo cilium-bgp-advertisement-loadbalancer.yaml com o nome de um recurso CiliumBGPAdvertisement para anunciar o endereço IP do balanceador de carga para o serviço que você criará na próxima etapa. Se você não estiver usando o Cilium BGP, poderá ignorar esta etapa. O endereço IP do balanceador de carga usado para seu serviço deve ser roteável em sua rede on-premises para que você possa consultar o serviço na etapa final.

    • O campo advertisementType está definido como Service e service.addresses está definido como LoadBalancerIP para anunciar somente o LoadBalancerIP para serviços do tipo LoadBalancer.

    • O campo selector está configurado para corresponder ao nome do serviço que você criará em uma etapa subsequente. Com essa configuração, somente o LoadBalancerIP para os serviços com o nome tcp-sample-service serão anunciados.

      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 o recurso CiliumBGPAdvertisement ao seu cluster. Se você não estiver usando o Cilium BGP, poderá ignorar esta etapa.

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

  6. Defina uma aplicação de amostra em um arquivo chamado tcp-sample-app.yaml. O exemplo abaixo usa uma implantação simples do NGINX com uma porta 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 a implantação ao seu cluster.

    kubectl apply -f tcp-sample-app.yaml

  8. Defina um serviço do tipo LoadBalancer para a implantação em um arquivo chamado tcp-sample-service.yaml.

    • Você pode solicitar um endereço IP específico do pool IP do balanceador de carga com a anotação lbipam.cilium.io/ips no objeto do serviço. Você pode remover essa anotação se não quiser solicitar um endereço IP específico para o serviço.

    • O campo de especificação loadBalancerClass é obrigatório para evitar que o provedor de Nuvem AWS herdado crie um Classic Load Balancer para o serviço. No exemplo abaixo, isso está configurado io.cilium/bgp-control-plane para usar o ambiente de gerenciamento BGP do Cilium como a classe do balanceador de carga. Como alternativa, esse campo pode ser configurado para que io.cilium/l2-announcer use o atributo L2 Announcements do Cilium (atualmente em versão beta e não compatível com a 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 o serviço ao seu cluster. O serviço será criado com um endereço IP externo que você poderá usar para acessar a aplicação.

    kubectl apply -f tcp-sample-service.yaml

  10. Verifique se o serviço foi criado com sucesso e tem um IP atribuído a ele a partir do CiliumLoadBalancerIPPool criado na etapa 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. Se você estiver usando o Cilium no modo de substituição do kube-proxy, você pode confirmar que o Cilium está lidando com o balanceamento de carga do serviço executando o comando a seguir. Na saída abaixo, os endereços 10.86.2.x são os endereços IP dos pods de backend para o serviço.

    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 se o Cilium está anunciando o endereço IP para a rede on-premises via BGP. No exemplo abaixo, há cinco nós híbridos, cada um anunciando o LB_IP_ADDRESS para o serviço de tcp-sample-service na rede on-premises.

    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. Acesse o serviço usando o endereço IP do balanceador de carga atribuído.

    curl LB_IP_ADDRESS

    Um exemplo de saída está abaixo.

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

  14. Limpe os recursos que você criou.

    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