Configurazione di servizi di tipo LoadBalancer per nodi ibridi - Amazon EKS
AWS Network Load BalancerBilanciamento del carico Cilium all'interno del cluster

Aiutaci a migliorare questa pagina

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link Modifica questa pagina nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Configurazione di servizi di tipo LoadBalancer per nodi ibridi

Questo argomento descrive come configurare il bilanciamento del carico di livello 4 (L4) per le applicazioni in esecuzione su nodi ibridi Amazon EKS. I servizi di tipo Kubernetes LoadBalancer vengono utilizzati per esporre applicazioni Kubernetes esterne al cluster. I servizi di questo tipo LoadBalancer vengono comunemente utilizzati con l'infrastruttura fisica di bilanciamento del carico di lavoro nel cloud o nell'ambiente locale per servire il traffico del carico di lavoro. Questa infrastruttura di bilanciamento del carico viene generalmente fornita con un controller specifico per l'ambiente.

AWS supporta AWS Network Load Balancer (NLB) e Cilium for Services di tipo in LoadBalancer esecuzione su nodi ibridi EKS. La decisione di utilizzare NLB o Cilium si basa sulla fonte del traffico delle applicazioni. Se il traffico dell'applicazione proviene da una AWS regione, AWS consiglia di utilizzare AWS NLB e Load Balancer Controller AWS . Se il traffico delle applicazioni proviene dall'ambiente locale locale locale o perimetrale, AWS consiglia di utilizzare le funzionalità di bilanciamento del carico integrate di Cilium, che possono essere utilizzate con o senza l'infrastruttura di bilanciamento del carico nell'ambiente.

Per il bilanciamento del carico del traffico delle applicazioni di livello 7 (L7), vedere. Configura Kubernetes Ingress per nodi ibridi Per informazioni generali sul bilanciamento del carico con EKS, consulta Best practice for Load Balancing.

AWS Network Load Balancer

Puoi utilizzare AWS Load Balancer Controller e NLB con il tipo di destinazione ip per i carichi di lavoro in esecuzione su nodi ibridi. Quando si utilizza il tipo di destinazioneip, NLB inoltra il traffico direttamente ai pod, aggirando il percorso di rete del livello di servizio. Affinché NLB raggiunga gli obiettivi IP del pod sui nodi ibridi, il pod CIDRs locale deve essere instradabile sulla rete locale. Inoltre, il AWS Load Balancer Controller utilizza webhook e richiede una comunicazione diretta dal piano di controllo EKS. Per ulteriori informazioni, consulta Configurare webhook per nodi ibridi.

Prerequisiti

Procedura

  1. Scarica una policy IAM per il AWS Load Balancer Controller che gli consenta di effettuare chiamate per tuo AWS APIs conto.

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

  2. Creare una policy IAM utilizzando le policy scaricate nel passaggio precedente.

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

  3. Sostituisci i valori per cluster name (CLUSTER_NAME), AWS Region (AWS_REGION) e AWS account ID (AWS_ACCOUNT_ID) con le tue impostazioni ed esegui il comando seguente.

    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. Aggiungi l'archivio di grafici eks-charts Helm. AWS mantiene questo repository attivo. GitHub

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

  5. Aggiorna il tuo repository Helm locale per assicurarti di avere i grafici più recenti.

    helm repo update eks

  6. Installa il AWS Load Balancer Controller. Sostituisci i valori per cluster name (CLUSTER_NAME), AWS Region (AWS_REGION), VPC ID (VPC_ID) e Load AWS Balancer Controller Helm chart version AWS_LBC_HELM_VERSION () con le tue impostazioni. Puoi trovare la versione più recente del grafico Helm eseguendo. helm search repo eks/aws-load-balancer-controller --versions Se stai eseguendo un cluster in modalità mista con nodi ibridi e nodi in AWS Cloud, puoi eseguire il AWS Load Balancer Controller sui nodi cloud seguendo le istruzioni riportate all'indirizzo. AWS Controller 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

  7. Verifica che il AWS Load Balancer Controller sia stato installato correttamente.

    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. Definire un'applicazione di esempio in un file denominatotcp-sample-app.yaml. L'esempio seguente utilizza una semplice implementazione NGINX con una 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. Applica la distribuzione al tuo cluster.

    kubectl apply -f tcp-sample-app.yaml

  10. Definisci un servizio di tipo LoadBalancer per la distribuzione in un file denominatotcp-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. Applica la configurazione del servizio al tuo cluster.

    kubectl apply -f tcp-sample-service.yaml

  12. Il provisioning del NLB per il Servizio potrebbe richiedere alcuni minuti. Una volta effettuato il provisioning del NLB, al Servizio verrà assegnato un indirizzo che corrisponde al nome DNS della distribuzione 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. Accedere al Servizio utilizzando l'indirizzo dell'NLB.

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

    Di seguito è riportato un esempio di output.

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

  14. Eliminare tutte le risorse create.

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

Bilanciamento del carico Cilium all'interno del cluster

Cilium può essere utilizzato come bilanciamento del carico all'interno del cluster per i carichi di lavoro in esecuzione su nodi ibridi EKS, il che può essere utile per ambienti che non dispongono di un'infrastruttura di bilanciamento del carico. Le funzionalità di bilanciamento del carico di Cilium si basano su una combinazione di funzionalità di Cilium, tra cui la sostituzione del kube-proxy, la gestione degli indirizzi IP Load Balancer (IPAM) e il piano di controllo BGP. Le responsabilità di queste funzionalità sono descritte di seguito:

  • Sostituzione del proxy Cilium kube: gestisce il traffico del servizio di routing verso i pod di backend.

  • Cilium Load Balancer IPAM: gestisce gli indirizzi IP che possono essere assegnati a servizi di tipo. LoadBalancer

  • Cilium BGP Control Plane: pubblicizza gli indirizzi IP assegnati da Load Balancer IPAM alla rete locale.

Se non si utilizza il kube-proxy sostitutivo di Cilium, è comunque possibile utilizzare Cilium Load Balancer IPAM e BGP Control Plane per allocare e assegnare indirizzi IP per servizi di tipo. LoadBalancer Se non utilizzate il sostituto kube-proxy di Cilium, il bilanciamento del carico di Services sui pod di backend viene gestito di default dalle regole kube-proxy e iptables in EKS.

Prerequisiti

Procedura

  1. Crea un file denominato cilium-lbip-pool-loadbalancer.yaml con una CiliumLoadBalancerIPPool risorsa per configurare l'intervallo di indirizzi IP Load Balancer per il tuo tipo di servizio. LoadBalancer

    • Sostituire LB_IP_CIDR con l'intervallo di indirizzi IP da utilizzare per gli indirizzi IP di Load Balancer. Per selezionare un singolo indirizzo IP, utilizza un /32 CIDR. Per ulteriori informazioni, consulta Gestione degli indirizzi LoadBalancer IP nella documentazione di Cilium.

    • Il serviceSelector campo è configurato in modo che corrisponda al nome del servizio che creerai in un passaggio successivo. Con questa configurazione, IPs da questo pool verranno assegnati solo i servizi con lo stesso nometcp-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. Applica la CiliumLoadBalancerIPPool risorsa al tuo cluster.

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

  3. Verifica che nel pool sia disponibile almeno un indirizzo IP.

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

  4. Crea un file denominato cilium-bgp-advertisement-loadbalancer.yaml con una CiliumBGPAdvertisement risorsa per pubblicizzare l'indirizzo IP del sistema di bilanciamento del carico per il servizio che creerai nel passaggio successivo. Se non utilizzi Cilium BGP, puoi saltare questo passaggio. L'indirizzo IP del load balancer utilizzato per il servizio deve essere instradabile sulla rete locale per poter interrogare il servizio nella fase finale.

    • Il advertisementType campo è impostato su Service ed service.addresses è impostato su per LoadBalancerIP pubblicizzare solo i servizi di tipo LoadBalancerIP for. LoadBalancer

    • Il selector campo è configurato in modo che corrisponda al nome del servizio che creerai in un passaggio successivo. Con questa configurazione, tcp-sample-service verranno pubblicizzati solo LoadBalancerIP i Servizi con lo stesso nome.

      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. Applica la CiliumBGPAdvertisement risorsa al tuo cluster. Se non utilizzi Cilium BGP, puoi saltare questo passaggio.

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

  6. Definire un'applicazione di esempio in un file denominato. tcp-sample-app.yaml L'esempio seguente utilizza una semplice implementazione NGINX con una 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. Applica la distribuzione al tuo cluster.

    kubectl apply -f tcp-sample-app.yaml

  8. Definisci un servizio di tipo LoadBalancer per la distribuzione in un file denominatotcp-sample-service.yaml.

    • È possibile richiedere un indirizzo IP specifico dal pool IP del sistema di bilanciamento del carico con l'lbipam.cilium.io/ipsannotazione sull'oggetto Service. È possibile rimuovere questa annotazione se non si desidera richiedere un indirizzo IP specifico per il Servizio.

    • Il campo loadBalancerClass spec è obbligatorio per impedire al AWS Cloud Provider precedente di creare un Classic Load Balancer per il servizio. Nell'esempio seguente, questo è configurato io.cilium/bgp-control-plane per utilizzare il BGP Control Plane di Cilium come classe di bilanciamento del carico. In alternativa, questo campo può essere configurato io.cilium/l2-announcer per utilizzare la funzionalità L2 Announcements di Cilium (attualmente in versione beta e non supportata ufficialmente da). 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. Applica il servizio al tuo cluster. Il servizio verrà creato con un indirizzo IP esterno che potrai utilizzare per accedere all'applicazione.

    kubectl apply -f tcp-sample-service.yaml

  10. Verifica che il servizio sia stato creato correttamente e che gli sia stato assegnato un IP corrispondente a quello CiliumLoadBalancerIPPool creato nel passaggio precedente.

    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 utilizzi Cilium in modalità sostitutiva kube-proxy, puoi confermare che Cilium sta gestendo il bilanciamento del carico per il Servizio eseguendo il comando seguente. Nell'output seguente, 10.86.2.x gli indirizzi sono gli indirizzi IP dei pod di backend per il Servizio.

    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. Conferma che Cilium stia pubblicizzando l'indirizzo IP sulla rete locale tramite BGP. Nell'esempio seguente, ci sono cinque nodi ibridi, ciascuno dei quali pubblicizza LB_IP_ADDRESS il tcp-sample-service servizio sulla rete locale.

    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. Accedi al servizio utilizzando l'indirizzo IP di bilanciamento del carico assegnato.

    curl LB_IP_ADDRESS

    Di seguito è riportato un esempio di output.

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

  14. Eliminare tutte le risorse create.

    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