**Contribuisci 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 dei 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 Amazon EKS Hybrid Nodes. I servizi Kubernetes di tipo LoadBalancer vengono utilizzati per esporre le applicazioni Kubernetes esterne al cluster. I servizi di tipo LoadBalancer vengono comunemente utilizzati con un’infrastruttura di bilanciamento del carico fisico in ambiente cloud oppure on-premises per servire il traffico del carico di lavoro. Questa infrastruttura di bilanciamento del carico viene in genere fornita con un controller specifico per l’ambiente. AWS supporta AWS Network Load Balancer (NLB) e Cilium per i servizi di tipo LoadBalancer in esecuzione su nodi ibridi EKS. La decisione di utilizzare NLB o Cilium si basa sulla fonte del traffico dell’applicazione. Se il traffico dell’applicazione proviene da una Regione AWS, AWS consiglia di utilizzare NLB di AWS e il controller del bilanciatore del carico di AWS. Se il traffico delle applicazioni proviene dall’ambiente locale on-premises o edge, 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), consulta [Configurazione dell’ingresso Kubernetes per nodi ibridi](hybrid-nodes-ingress.md). Per informazioni generali sul bilanciamento del carico con EKS, consulta [Best Practices for Load Balancing](https://docs.aws.amazon.com/eks/latest/best-practices/load-balancing.html). ## Network Load Balancer di AWS Puoi utilizzare il [Controller di bilanciatore del carico di AWS](aws-load-balancer-controller.md) e NLB con il tipo di destinazione `ip` per i carichi di lavoro in esecuzione su nodi ibridi. Quando utilizzi il tipo di destinazione `ip`, NLB inoltra il traffico direttamente ai pod, aggirando il percorso di rete del livello di servizio. Affinché NLB raggiunga le destinazioni IP dei pod sui nodi ibridi, i pod CIDR on-premises devono essere instradabili sulla rete on-premises. Inoltre, il Controller del bilanciatore del carico di AWS utilizza webhook e richiede una comunicazione diretta dal piano di controllo EKS. Per ulteriori informazioni, consulta [Configurazione di webhook per nodi ibridi](hybrid-nodes-webhooks.md). + Consulta [Esecuzione del routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md) per i requisiti di configurazione delle sottoreti, consulta [Installa il AWS Load Balancer Controller con Helm](lbc-helm.md) e [Best Practices for Load Balancing](https://docs.aws.amazon.com/eks/latest/best-practices/load-balancing.html) per ulteriori informazioni sul Network Load Balancer di AWS e il Controller del bilanciatore del carico di AWS. + Consulta le [AWS Load Balancer Controller NLB configurations](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/nlb/) per le configurazioni che possono essere applicate ai servizi di tipo `LoadBalancer` con il Network Load Balancer di AWS. ### Prerequisiti + Cilium è installato seguendo le istruzioni contenute in [Configurazione della CNI per nodi ibridi](hybrid-nodes-cni.md). + Il piano di controllo BGP di Cilium è abilitato seguendo le istruzioni contenute in [Configurazione di Cilium BGP per nodi ibridi](hybrid-nodes-cilium-bgp.md). Se non desideri utilizzare BGP, devi utilizzare un metodo alternativo per rendere i pod CIDR on-premises instradabili sulla rete on-premises; consulta [CIDR dei pod remoti instradabili](hybrid-nodes-concepts-kubernetes.md#hybrid-nodes-concepts-k8s-pod-cidrs) per ulteriori informazioni. + Helm è installato nell’ambiente a riga di comando, consulta [Setup Helm instructions](helm.md). + eksctl è installato nell’ambiente a riga di comando, consulta [Setup eksctl instructions](install-kubectl.md#eksctl-install-update). ### Procedura 1. Scaricare una policy IAM per il Controller del bilanciatore del carico AWS che consente di effettuare chiamate alle API AWS per conto dell’utente. ``` curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/refs/heads/main/docs/install/iam_policy.json ``` 1. Creare una policy IAM utilizzando le policy scaricate nel passaggio precedente. ``` aws iam create-policy \ --policy-name AWSLoadBalancerControllerIAMPolicy \ --policy-document file://iam_policy.json ``` 1. Sostituisci i valori per il nome del cluster (`CLUSTER_NAME`), la Regione AWS (`AWS_REGION`) e l’ID dell’account AWS (`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 ``` 1. Aggiungi il repository di grafici Helm eks-charts. AWS conserva questo repository su GitHub. ``` helm repo add eks https://aws.github.io/eks-charts ``` 1. Aggiorna il repository locale per assicurarti di avere i grafici più recenti. ``` helm repo update eks ``` 1. Installazione del Controller del bilanciatore del carico AWS. Sostituisci i valori per il nome del cluster (`CLUSTER_NAME`), la Regione AWS (`AWS_REGION`), l’ID del VPC (`VPC_ID`) e la versione del Controller del bilanciatore del carico di AWS del grafico Helm (`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 nel Cloud di AWS, puoi eseguire il Controller del bilanciatore del carico di AWS sui nodi cloud seguendo le istruzioni riportate in [Controller del bilanciatore del carico 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. Verifica che il Controller del bilanciatore del carico di AWS 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 ``` 1. Definisci 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 ``` 1. Applica l’implementazione al cluster. ``` kubectl apply -f tcp-sample-app.yaml ``` 1. Definisci un servizio di tipo LoadBalancer per l’implementazione in un file denominato `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. Applica la mappa di configurazione al cluster. ``` kubectl apply -f tcp-sample-service.yaml ``` 1. Il provisioning dell’NLB per il Servizio può richiedere alcuni minuti. Una volta effettuato il provisioning dell’NLB, al Servizio verrà assegnato un indirizzo che corrisponde al nome DNS dell’implementazione dell’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. Accedi al Servizio utilizzando l’indirizzo dell’NLB. ``` curl k8s-default-tcpsampl-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb..amazonaws.com ``` Di seguito viene riportato un output di esempio. ``` Welcome to nginx! [...] ``` 1. 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 bilanciatore 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 indirizzi IP (IPAM) del bilanciatore del carico e il piano di controllo BGP. Le responsabilità di queste funzionalità sono descritte di seguito: + **Sostituzione del Cilium proxy-kube**: gestisce il traffico del servizio di routing verso i pod di backend. + **IPAM del bilanciatore del carico Cilium**: gestisce gli indirizzi IP che possono essere assegnati a servizi di tipo `LoadBalancer`. + **Piano di controllo BGP Cilium**: pubblicizza gli indirizzi IP assegnati dalla IPAM del bilanciatore del carico alla rete on-premises. Se non utilizzi la sostituzione del kube-proxy Cilium, puoi comunque utilizzare l’IPAM del bilanciatore del carico e il Piano di controllo BGP Cilium per allocare e assegnare indirizzi IP per i servizi di tipo LoadBalancer. Se non utilizzi la sostituzione del kube-proxy Cilium, il bilanciamento del carico dei servizi sui pod di backend viene gestito per impostazione predefinita dalle regole kube-proxy e iptables in EKS. ### Prerequisiti + Cilium è stato installato seguendo le istruzioni contenute in [Configurazione della CNI per nodi ibridi](hybrid-nodes-cni.md) con o senza la sostituzione di kube-proxy abilitata. La sostituzione del kube-proxy Cilium richiede l’esecuzione di un sistema operativo con un kernel Linux recente come v4.19.57, v5.1.16 o v5.2.0. Tutte le versioni recenti dei sistemi operativi supportati per l’uso con nodi ibridi soddisfano questi criteri, ad eccezione di Red Hat Enterprise Linux (RHEL) 8.x. + Il piano di controllo BGP di Cilium è abilitato seguendo le istruzioni contenute in [Configurazione di Cilium BGP per nodi ibridi](hybrid-nodes-cilium-bgp.md). Se non desideri utilizzare BGP, devi utilizzare un metodo alternativo per rendere i pod CIDR on-premises instradabili sulla rete on-premises; consulta [CIDR dei pod remoti instradabili](hybrid-nodes-concepts-kubernetes.md#hybrid-nodes-concepts-k8s-pod-cidrs) per ulteriori informazioni. + Helm è installato nell’ambiente a riga di comando, consulta [Setup Helm instructions](helm.md). ### Procedura 1. Crea un file denominato `cilium-lbip-pool-loadbalancer.yaml` con una risorsa `CiliumLoadBalancerIPPool` per configurare l’intervallo di indirizzi IP del bilanciatore del carico per i tuoi servizi di tipo LoadBalancer. + Sostituisci `LB_IP_CIDR` con l’intervallo di indirizzi IP da utilizzare per quelli del bilanciatore del carico. Per selezionare un singolo indirizzo IP, utilizza un CIDR `/32`. Per ulteriori informazioni, consulta [LoadBalancer IP Address Management](https://docs.cilium.io/en/stable/network/lb-ipam/) nella documentazione di Cilium. + Il campo `serviceSelector` è configurato in modo che corrisponda al nome del servizio che creerai in un passaggio successivo. Con questa configurazione, gli IP di questo pool verranno assegnati solo ai servizi con lo stesso 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 ``` 1. Applica la risorsa `CiliumLoadBalancerIPPool` al cluster. ``` kubectl apply -f cilium-lbip-pool-loadbalancer.yaml ``` 1. 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 ``` 1. Crea un file denominato `cilium-bgp-advertisement-loadbalancer.yaml` con una risorsa `CiliumBGPAdvertisement` per pubblicizzare l’indirizzo IP del bilanciatore del carico per il servizio che creerai nel passaggio successivo. Se non utilizzi un BGP di Cilium, puoi ignorare questo passaggio. L’indirizzo IP del bilanciatore del carico utilizzato per il servizio deve essere instradabile sulla rete on-premises per consentire all’utente di interrogare il servizio nella Passaggio finale. + Il campo `advertisementType` è impostato su `Service` e `service.addresses` è impostato su `LoadBalancerIP` per pubblicizzare solo l’`LoadBalancerIP` per i servizi di tipo `LoadBalancer`. + Il campo `selector` è configurato in modo che corrisponda al nome del servizio che creerai in un passaggio successivo. Con questa configurazione, verrà pubblicizzato solo l’`LoadBalancerIP` per i servizi con lo stesso nome `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. Applica la risorsa `CiliumBGPAdvertisement` al cluster. Se non utilizzi un BGP di Cilium, puoi ignorare questo passaggio. ``` kubectl apply -f cilium-bgp-advertisement-loadbalancer.yaml ``` 1. Definisci 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 ``` 1. Applica l’implementazione al cluster. ``` kubectl apply -f tcp-sample-app.yaml ``` 1. Definisci un servizio di tipo LoadBalancer per l’implementazione in un file denominato `tcp-sample-service.yaml`. + Puoi richiedere un indirizzo IP specifico dal pool di IP del bilanciatore del carico con l’annotazione `lbipam.cilium.io/ips` sull’oggetto del servizio. Puoi rimuovere questa annotazione se non desideri richiedere un indirizzo IP specifico per il servizio. + Il campo della specifica `loadBalancerClass` è obbligatorio per impedire al provider cloud di AWS precedente di creare un Classic Load Balancer per il servizio. Nell’esempio seguente, questo è configurato su `io.cilium/bgp-control-plane` per utilizzare il piano di controllo BGP di Cilium come classe di bilanciatore del carico. In alternativa, questo campo può essere configurato su `io.cilium/l2-announcer` per utilizzare la [Funzionalità L2 Announcements](https://docs.cilium.io/en/latest/network/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 ``` 1. Applica il servizio al cluster. Il servizio verrà creato con un indirizzo IP esterno che puoi utilizzare per accedere all’applicazione. ``` kubectl apply -f tcp-sample-service.yaml ``` 1. Verifica che il servizio sia stato creato correttamente e che gli sia stato assegnato un IP dal `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 ``` 1. Se utilizzi Cilium in modalità kube-proxy sostitutivo, puoi confermare che Cilium sta gestendo il bilanciamento del carico per il servizio eseguendo il comando seguente. Nell’output seguente, gli indirizzi `10.86.2.x` 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) ``` 1. Conferma che Cilium stia pubblicizzando l’indirizzo IP sulla rete on-premises tramite BGP. Nell’esempio seguente ci sono cinque nodi ibridi, ciascuno dei quali pubblicizza `LB_IP_ADDRESS` per il servizio `tcp-sample-service` sulla rete 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}] ``` 1. Accedi al servizio utilizzando l’indirizzo IP del bilanciatore del carico assegnato. ``` curl {{LB_IP_ADDRESS}} ``` Di seguito viene riportato un output di esempio. ``` Welcome to nginx! [...] ``` 1. 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 ```