AWS Network Load Balancer Équilibrage de charge au sein du 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.

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 exécutées sur des nœuds hybrides Amazon EKS. Les services Kubernetes de type Kubernetes LoadBalancer sont utilisés pour exposer les applications Kubernetes externes au cluster. Les services de ce type LoadBalancer sont couramment utilisés avec une infrastructure d'équilibrage de charge physique dans le cloud ou dans un environnement sur site pour répondre au trafic de la charge de travail. Cette infrastructure d'équilibreur de charge est généralement fournie avec un contrôleur spécifique à l'environnement.

AWS prend en charge AWS Network Load Balancer (NLB) et Cilium pour les services de type LoadBalancer exécutés sur des nœuds hybrides EKS. La décision d'utiliser NLB ou Cilium est basée sur la source du trafic applicatif. Si le trafic d'applications provient d'une AWS région, il est AWS recommandé d'utiliser AWS NLB et le AWS Load Balancer Controller. Si le trafic applicatif provient de l'environnement local sur site ou périphérique, il est AWS recommandé d'utiliser les fonctionnalités d'équilibrage de charge intégrées de Cilium, qui peuvent être utilisées avec ou sans infrastructure d'équilibreur de charge dans votre environnement.

Pour l'équilibrage de la charge du trafic des applications de couche 7 (L7), voirConfigurer Kubernetes Ingress pour les nœuds hybrides. Pour des informations générales sur l'équilibrage de charge avec EKS, consultez la section Meilleures pratiques en matière d'équilibrage de charge.

AWS Network Load Balancer

Vous pouvez utiliser le AWS Load Balancer Controller et le NLB avec le type de cible ip pour les charges de travail exécutées sur des nœuds hybrides. Lors de l'utilisation du type de cibleip, NLB transmet le trafic directement aux pods, en contournant le chemin réseau de la couche Service. Pour que NLB atteigne les cibles IP du pod sur les nœuds hybrides, votre pod local CIDRs doit être routable sur votre réseau local. En outre, le 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, veuillez consulter Configurer les webhooks pour les nœuds hybrides.

Acheminez le trafic TCP et UDP avec des équilibreurs de charge réseauPour plus d'informations sur AWS Network Load Balancer Installez le contrôleur AWS Load Balancer avec Helm et Load Balancer Controller, reportez-vous aux sections « Best Practices for Load Balancer » et « Best Practices for Load AWS Balancer ».
Consultez AWS la section Configurations NLB du Load Balancer Controller pour les configurations qui peuvent être appliquées à des services de type LoadBalancer Network AWS Load Balancer.

Prérequis

Cilium installé en suivant les instructions fournies dans. Configurer le CNI pour les nœuds hybrides
Le plan de contrôle BGP de Cilium est activé en suivant les instructions de. Configurer Cilium BGP pour les nœuds hybrides Si vous ne souhaitez pas utiliser BGP, vous devez utiliser une autre méthode pour rendre votre pod local CIDRs routable sur votre réseau local, voir Pod à distance routable CIDRs pour plus d'informations.
Helm est installé dans votre environnement de ligne de commande, voir les instructions de configuration de Helm.
eksctl installé dans votre environnement de ligne de commande, consultez les instructions de configuration d'eksctl.

Procédure

Téléchargez une politique IAM pour le AWS Load Balancer Controller qui lui permet de passer des appels en votre AWS APIs nom.


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

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

Remplacez les valeurs du nom du cluster (CLUSTER_NAME), de AWS la région (AWS_REGION) et de l'ID de AWS compte (AWS_ACCOUNT_ID) par vos paramètres et 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

Ajoutez le référentiel de cartes eks-charts Helm. AWS maintient ce dépôt activé GitHub.
```
helm repo add eks https://aws.github.io/eks-charts
```
Mettez à jour votre dépôt Helm local pour vous assurer que vous disposez des cartes les plus récentes.
```
helm repo update eks
```
Installez le AWS Load Balancer Controller. Remplacez les valeurs du nom du cluster (CLUSTER_NAME), de AWS la région (AWS_REGION), de l'ID VPC (VPC_ID) et de la version du graphique AWS Load Balancer Controller Helm AWS_LBC_HELM_VERSION () par vos paramètres. Vous pouvez trouver la dernière version du graphique Helm en exécutanthelm search repo eks/aws-load-balancer-controller --versions. Si vous utilisez un cluster en mode mixte avec à la fois des nœuds hybrides et des nœuds dans le AWS cloud, vous pouvez exécuter le AWS Load Balancer Controller sur les nœuds du cloud en suivant les instructions indiquées sur. AWS Contrôleur Load Balancer
```
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
```

Vérifiez que le AWS Load Balancer Controller a été correctement installé.


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

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

Appliquez le déploiement à votre cluster.
```
kubectl apply -f tcp-sample-app.yaml
```

Définissez un type de service 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

Appliquez la configuration du service à votre cluster.
```
kubectl apply -f tcp-sample-service.yaml
```

La mise en service 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 du 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

Accédez au service en utilisant l'adresse du NLB.


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

Vous trouverez ci-dessous un exemple de sortie.


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

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 au sein du cluster Cilium

Cilium peut être utilisé comme équilibreur de charge intégré au cluster pour les charges de travail exécutées sur des nœuds hybrides EKS, ce qui peut être utile pour les environnements dépourvus d'infrastructure d'équilibreur de charge. Les capacités d'équilibrage de charge de Cilium reposent sur une combinaison de fonctionnalités de Cilium, notamment le remplacement du proxy Kube, la gestion des adresses IP Load Balancer (IPAM) et le plan de contrôle BGP. Les responsabilités liées à ces fonctionnalités sont détaillées ci-dessous :

Remplacement du proxy Cilium Kube : gère le routage du trafic du service vers les pods principaux.
Cilium Load Balancer IPAM : gère les adresses IP qui peuvent être attribuées aux types de services. LoadBalancer
Plan de contrôle BGP de Cilium : annonce les adresses IP allouées par Load Balancer IPAM au réseau local.

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

Prérequis

Cilium a été installé en suivant les instructions fournies Configurer le CNI pour les nœuds hybrides avec ou sans le remplacement du proxy Kube activé. Le remplacement du proxy kube 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 compatibles avec les nœuds hybrides répondent à ces critères, à l'exception de Red Hat Enterprise Linux (RHEL) 8.x.
Le plan de contrôle BGP de Cilium est activé en suivant les instructions de. Configurer Cilium BGP pour les nœuds hybrides Si vous ne souhaitez pas utiliser BGP, vous devez utiliser une autre méthode pour rendre votre pod local CIDRs routable sur votre réseau local, voir Pod à distance routable CIDRs pour plus d'informations.
Helm est installé dans votre environnement de ligne de commande, voir les instructions de configuration de Helm.

Procédure

Créez un fichier nommé cilium-lbip-pool-loadbalancer.yaml avec une CiliumLoadBalancerIPPool ressource pour configurer la plage d'adresses IP Load Balancer pour votre type de services. LoadBalancer
- Remplacez LB_IP_CIDR par la plage d'adresses IP à utiliser pour les adresses IP du Load Balancer. Pour sélectionner une adresse IP unique, utilisez un /32 CIDR. Pour plus d'informations, consultez la section Gestion des adresses LoadBalancer IP dans la documentation de Cilium.
- Le serviceSelector champ est configuré pour correspondre au nom du service que vous allez créer lors d'une étape ultérieure. Avec cette configuration, seuls les services portant le nom seront alloués à IPs partir de ce pooltcp-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
```
Appliquez la CiliumLoadBalancerIPPool ressource à votre cluster.
```
kubectl apply -f cilium-lbip-pool-loadbalancer.yaml
```

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

Créez un fichier nommé cilium-bgp-advertisement-loadbalancer.yaml avec une CiliumBGPAdvertisement ressource 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 local pour que vous puissiez interroger le service lors de la dernière étape.
- Le advertisementType champ est défini sur Service et service.addresses est configuré LoadBalancerIP pour n'annoncer que le type LoadBalancerIP pour les servicesLoadBalancer.
- Le selector champ est configuré pour correspondre au nom du service que vous allez créer lors d'une étape ultérieure. Avec cette configuration, seuls LoadBalancerIP 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
```
Appliquez la CiliumBGPAdvertisement ressource à votre cluster. Si vous n'utilisez pas Cilium BGP, vous pouvez ignorer cette étape.
```
kubectl apply -f cilium-bgp-advertisement-loadbalancer.yaml
```

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

Appliquez le déploiement à votre cluster.
```
kubectl apply -f tcp-sample-app.yaml
```
Définissez un type de service LoadBalancer pour le déploiement dans un fichier nommétcp-sample-service.yaml.
- Vous pouvez demander une adresse IP spécifique au pool d'adresses IP de l'équilibreur de charge avec l'lbipam.cilium.io/ipsannotation sur l'objet Service. Vous pouvez supprimer cette annotation si vous ne souhaitez pas demander d'adresse IP spécifique pour le Service.
- Le champ de loadBalancerClass spécification est obligatoire pour empêcher l'ancien fournisseur de AWS cloud de créer un Classic Load Balancer pour le service. Dans l'exemple ci-dessous, cela est configuré io.cilium/bgp-control-plane pour utiliser le plan de contrôle BGP de Cilium comme classe d'équilibreur de charge. Ce champ peut également être configuré io.cilium/l2-announcer pour utiliser la fonctionnalité d'annonces L2 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
```
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
```

Vérifiez que le service a été créé avec succès et qu'une adresse IP lui a été attribuée à partir de CiliumLoadBalancerIPPool celle créée à 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

Si vous utilisez Cilium en mode de remplacement du proxy kube, vous pouvez confirmer que Cilium gère l'équilibrage de charge pour le service en exécutant la commande suivante. Dans le résultat ci-dessous, les 10.86.2.x adresses sont les adresses IP des modules principaux 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)

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

Accédez au service à l'aide de l'adresse IP d'équilibrage de charge attribuée.
```
curl LB_IP_ADDRESS
               
```
Vous trouverez ci-dessous un exemple de sortie.
```
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
[...]
```

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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Configurer Ingress

Configuration des politiques réseau