Configurer les services de type LoadBalancer pour les nœuds hybrides - Amazon EKS
AWS Network Load BalancerÉquilibrage de charge dans le cluster Cilium

Aidez à améliorer cette page

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien Modifier cette page sur qui se trouve dans le volet droit de chaque page.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Configurer les services de type LoadBalancer pour les nœuds hybrides

Cette rubrique décrit comment configurer l’équilibrage de charge de couche 4 (L4) pour les applications s’exécutant sur des nœuds hybrides Amazon EKS. Les services Kubernetes de type LoadBalancer sont utilisés pour exposer les applications Kubernetes à l’extérieur du cluster. Les services de type LoadBalancer sont couramment utilisés avec une infrastructure d’équilibrage de charge physique dans le cloud ou dans un environnement sur site pour traiter le trafic de la charge de travail. Cette infrastructure d’équilibrage de charge est généralement fournie avec un contrôleur spécifique à l’environnement.

AWS prend en charge Network Load Balancer (NLB) AWS et Cilium pour les services de type LoadBalancer s’exécutant sur des nœuds hybrides EKS. La décision d’utiliser NLB ou Cilium dépend de la source du trafic applicatif. Si le trafic applicatif provient d’une région AWS, AWS recommande d’utiliser AWS NLB ainsi que l’AWS Load Balancer Controller. Si le trafic applicatif provient de l’environnement local sur site ou périphérique, AWS recommande d’utiliser les capacités de répartition de charge intégrées à Cilium, qui peuvent être utilisées avec ou sans infrastructure d’équilibrage de charge dans votre environnement.

Pour l’équilibrage de charge du trafic des applications de couche 7 (L7), voir Configurer Kubernetes Ingress pour les nœuds hybrides. Pour obtenir des informations générales sur l’équilibrage de charge avec EKS, consultez la section Meilleures pratiques pour l’équilibrage de charge.

AWS Network Load Balancer

Vous pouvez utiliser l’AWS Load Balancer Controller et NLB avec le type de cible ip pour les charges de travail s’exécutant sur des nœuds hybrides. Lorsque vous utilisez le type de cible ip, NLB transfère le trafic directement vers les pods, en contournant le chemin réseau de la couche Service. Pour que NLB atteigne les cibles IP des pods sur les nœuds hybrides, vos CIDR de pods sur site doivent être routables sur votre réseau sur site. De plus, l’AWS Load Balancer Controller utilise des webhooks et nécessite une communication directe depuis le plan de contrôle EKS. Pour de plus amples informations, consultez Configurer les webhooks pour les nœuds hybrides.

Prérequis

Procédure

  1. Téléchargez une politique IAM pour le contrôleur de l'équilibreur de charge AWS qui lui permet d'effectuer des appels aux API AWS en votre nom.

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

  2. Créez une politique IAM à l'aide de la politique téléchargée à l'étape précédente.

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

  3. Remplacez les valeurs pour le nom du cluster (CLUSTER_NAME), la région AWS (AWS_REGION) et l’ID du compte AWS (AWS_ACCOUNT_ID) par vos paramètres, puis exécutez la commande suivante.

    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. Ajoutez le référentiel des Charts de Helm eks-charts. AWS maintient ce référentiel sur GitHub.

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

  5. Mettez à jour votre référentiel Helm local pour vous assurer que vous disposez des graphiques les plus récents.

    helm repo update eks

  6. Installez le contrôleur de l'équilibreur de charge AWS. Remplacez les valeurs pour le nom du cluster (CLUSTER_NAME), la région AWS (AWS_REGION), l’ID VPC (VPC_ID) et la version des Charts de Helm de l’AWS Load Balancer Controller (AWS_LBC_HELM_VERSION) par vos paramètres. Vous pouvez trouver la dernière version des Charts de Helm en exécutant helm search repo eks/aws-load-balancer-controller --versions. Si vous utilisez un cluster en mode mixte avec des nœuds hybrides et des nœuds dans le cloud AWS, vous pouvez exécuter l’AWS Load Balancer Controller sur les nœuds cloud en suivant les instructions disponibles à l’adresse Contrôleur de l'équilibreur de charge 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. Vérifiez que l’AWS Load Balancer Controller a été installé correctement.

    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. Définissez un exemple d’application dans un fichier nommé tcp-sample-app.yaml. L’exemple ci-dessous utilise un déploiement NGINX simple avec un port 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. Appliquez le déploiement à votre cluster.

    kubectl apply -f tcp-sample-app.yaml

  10. Définissez un service de type LoadBalancer pour le déploiement dans un fichier nommé 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. Appliquez la configuration du service à votre cluster.

    kubectl apply -f tcp-sample-service.yaml

  12. La configuration du NLB pour le service peut prendre quelques minutes. Une fois le NLB provisionné, le service se verra attribuer une adresse correspondant au nom DNS du déploiement 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. Accédez au service à l’aide de l’adresse du NLB.

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

    Un exemple de résultat est présenté ci-dessous.

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

  14. Nettoyez les ressources que vous avez créées.

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

Équilibrage de charge dans le cluster Cilium

Cilium peut être utilisé comme équilibreur de charge intra-cluster pour les charges de travail exécutées sur des nœuds hybrides EKS, ce qui peut s’avérer utile pour les environnements qui ne disposent pas d’infrastructure d’équilibrage de charge. Les capacités d’équilibrage de charge de Cilium reposent sur une combinaison de fonctionnalités Cilium, notamment le remplacement de kube-proxy, la gestion des adresses IP de l’équilibreur de charge (IPAM) et le plan de contrôle BGP. Les responsabilités de ces fonctionnalités sont détaillées ci-dessous :

  • Remplacement de Cilium kube-proxy : gère le routage du trafic des services vers les pods dorsaux.

  • Cilium Load Balancer IPAM : gère les adresses IP pouvant être attribuées aux services de type LoadBalancer.

  • Plan de contrôle Cilium BGP : annonce les adresses IP attribuées par le Load Balancer IPAM au réseau local.

Si vous n’utilisez pas le remplacement kube-proxy de Cilium, vous pouvez toujours utiliser Cilium Load Balancer IPAM et BGP Control Plane pour allouer et attribuer des adresses IP aux services de type LoadBalancer. Si vous n’utilisez pas le remplacement kube-proxy de Cilium, l’équilibrage de charge pour les services vers les pods dorsaux est géré par kube-proxy et les règles iptables par défaut dans EKS.

Prérequis

  • Cilium installé en suivant les instructions dans Configurer CNI pour les nœuds hybrides, avec ou sans remplacement de kube-proxy activé. Le remplacement de kube-proxy par Cilium nécessite l’exécution d’un système d’exploitation avec un noyau Linux au moins aussi récent que v4.19.57, v5.1.16 ou v5.2.0. Toutes les versions récentes des systèmes d’exploitation pris en charge pour une utilisation avec des nœuds hybrides répondent à ces critères, à l’exception de Red Hat Enterprise Linux (RHEL) 8.x.

  • Le plan de contrôle Cilium BGP a été activé en suivant les instructions fournies dans Configurer Cilium BGP pour les nœuds hybrides. Si vous ne souhaitez pas utiliser BGP, vous devez utiliser une autre méthode pour rendre vos CIDR de pods sur site routables sur votre réseau sur site. Pour plus d’informations, consultez CIDR de pods distants routables.

  • Helm installé dans votre environnement de ligne de commande, consultez les Instructions de configuration de Helm.

Procédure

  1. Créez un fichier nommé cilium-lbip-pool-loadbalancer.yaml avec une ressource CiliumLoadBalancerIPPool pour configurer la plage d’adresses IP du Load Balancer pour vos services de type LoadBalancer.

    • Remplacez LB_IP_CIDR par la plage d’adresses IP à utiliser pour les adresses IP de l’équilibreur de charge. Pour sélectionner une seule adresse IP, utilisez un CIDR /32. Pour plus d’informations, consultez la section Gestion des adresses IP LoadBalancer dans la documentation Cilium.

    • Le champ serviceSelector est configuré pour correspondre au nom du service que vous créerez à l’étape suivante. Avec cette configuration, les adresses IP de ce pool ne seront attribuées qu’aux services portant le nom 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. Appliquez la ressource CiliumLoadBalancerIPPool à votre cluster.

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

  3. Vérifiez qu’au moins une adresse IP est disponible dans le pool.

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

  4. Créez un fichier nommé cilium-bgp-advertisement-loadbalancer.yaml avec une ressource CiliumBGPAdvertisement pour annoncer l’adresse IP de l’équilibreur de charge pour le service que vous allez créer à l’étape suivante. Si vous n’utilisez pas Cilium BGP, vous pouvez ignorer cette étape. L’adresse IP de l’équilibreur de charge utilisée pour votre service doit être routable sur votre réseau sur site afin que vous puissiez interroger le service lors de la dernière étape.

    • Le champ advertisementType est défini sur Service et service.addresses est défini sur LoadBalancerIP pour annoncer uniquement le LoadBalancerIP pour les services de type LoadBalancer.

    • Le champ selector est configuré pour correspondre au nom du service que vous créerez à l’étape suivante. Avec cette configuration, seul LoadBalancerIP pour les services portant le nom tcp-sample-service seront annoncés.

      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. Appliquez la ressource CiliumBGPAdvertisement à votre cluster. Si vous n’utilisez pas Cilium BGP, vous pouvez ignorer cette étape.

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

  6. Définissez un exemple d’application dans un fichier nommé tcp-sample-app.yaml. L’exemple ci-dessous utilise un déploiement NGINX simple avec un port 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. Appliquez le déploiement à votre cluster.

    kubectl apply -f tcp-sample-app.yaml

  8. Définissez un service de type LoadBalancer pour le déploiement dans un fichier nommé tcp-sample-service.yaml.

    • Vous pouvez demander une adresse IP spécifique à partir du pool d’adresses IP de l’équilibreur de charge à l’aide de l’annotation lbipam.cilium.io/ips sur l’objet Service. Vous pouvez supprimer cette annotation si vous ne souhaitez pas demander une adresse IP spécifique pour le Service.

    • Le champ spec loadBalancerClass est obligatoire afin d’empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service. Dans l’exemple ci-dessous, cela est configuré sur io.cilium/bgp-control-plane pour utiliser le plan de contrôle BGP de Cilium comme classe d’équilibrage de charge. Ce champ peut également être configuré sur io.cilium/l2-announcer pour utiliser la fonctionnalité L2 Announcements de Cilium (actuellement en version bêta et non officiellement prise en charge par 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. Appliquez le service à votre cluster. Le service sera créé avec une adresse IP externe que vous pourrez utiliser pour accéder à l’application.

    kubectl apply -f tcp-sample-service.yaml

  10. Vérifiez que le service a été créé avec succès et qu’une adresse IP lui a été attribuée à partir du CiliumLoadBalancerIPPool créé à l’étape précédente.

    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 vous utilisez Cilium en mode de remplacement de kube-proxy, vous pouvez vérifier que Cilium gère l’équilibrage de charge pour le service en exécutant la commande suivante. Dans la sortie ci-dessous, les adresses 10.86.2.x sont les adresses IP des pods dorsaux du service.

    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. Confirmez que Cilium annonce l’adresse IP au réseau local via BGP. Dans l’exemple ci-dessous, il existe cinq nœuds hybrides, chacun annonçant le LB_IP_ADDRESS pour le service tcp-sample-service au réseau local.

    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. Accédez au service à l’aide de l’adresse IP de l’équilibreur de charge attribué.

    curl LB_IP_ADDRESS

    Un exemple de résultat est présenté ci-dessous.

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

  14. Nettoyez les ressources que vous avez créées.

    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