**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 dell’ingresso Kubernetes per nodi ibridi
Questo argomento descrive come configurare l’ingresso Kubernetes per i carichi di lavoro in esecuzione su Amazon EKS Hybrid Nodes. L’[ingresso Kubernetes](https://kubernetes.io/docs/concepts/services-networking/ingress/) espone i percorsi HTTP e HTTPS dall’esterno del cluster ai servizi all’interno del cluster. Per utilizzare le risorse dell’ingresso, è necessario un controller dell’ingresso Kubernetes per configurare l’infrastruttura di rete e i componenti che servono il traffico di rete.
AWS supporta AWS Application Load Balancer (ALB) e Cilium for Kubernetes Ingress per carichi di lavoro in esecuzione su nodi ibridi EKS. La decisione di utilizzare ALB o Cilium per l’ingresso si basa sulla fonte del traffico delle applicazioni. Se il traffico dell'applicazione proviene da una AWS regione, AWS consiglia di utilizzare AWS ALB e il Load AWS Balancer Controller. Se il traffico delle applicazioni proviene dall'ambiente locale locale locale o perimetrale, AWS consiglia di utilizzare le funzionalità Ingress integrate di Cilium, che possono essere utilizzate con o senza l'infrastruttura di bilanciamento del carico nell'ambiente.
## AWS Application Load Balancer
Puoi utilizzare il [Controller del bilanciatore del carico AWS](aws-load-balancer-controller.md) e Application Load Balancer (ALB) con il tipo di destinazione `ip` per i carichi di lavoro in esecuzione su nodi ibridi. Quando si utilizza il tipo di destinazione `ip`, ALB inoltra il traffico direttamente ai pod, aggirando il percorso di rete del livello di servizio. Affinché ALB raggiunga le destinazioni IP del pod sui nodi ibridi, il CIDR del pod on-premises 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 [Configurazione di webhook per nodi ibridi](hybrid-nodes-webhooks.md).
### Considerazioni
+ [Installa il AWS Load Balancer Controller con Helm](lbc-helm.md)Per ulteriori informazioni, vedere [Instradare il traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md) AWS Application Load Balancer e Load Balancer AWS Controller.
+ Consulta [Best Practices for Load Balancing](https://docs.aws.amazon.com/eks/latest/best-practices/load-balancing.html) per informazioni su come scegliere tra AWS Application Load Balancer AWS e Network Load Balancer.
+ Vedi [AWS Load Balancer Controller Ingress annotations per l'elenco delle annotazioni](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/) che possono essere configurate per le risorse Ingress con Application Load Balancer. 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 si desidera utilizzare BGP, è necessario utilizzare un metodo alternativo per rendere il pod locale instradabile sulla rete locale. CIDRs Se non rendi CIDRs instradabile il pod locale, ALB non sarà in grado di registrarlo o contattare i destinatari IP del pod.
+ Helm è installato nell’ambiente a riga di comando, consulta le [istruzioni di configurazione di Helm](helm.md) per ulteriori informazioni.
+ eksctl è installato nell’ambiente a riga di comando, consulta le [istruzioni di installazione di eksctl](install-kubectl.md#eksctl-install-update) per ulteriori informazioni.
### 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
```
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 il valore 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
```
1. Aggiungi il repository di grafici Helm di eks-charts e aggiorna il repository Helm locale per assicurarti di avere i grafici più recenti.
```
helm repo add eks https://aws.github.io/eks-charts
```
```
helm repo update eks
```
1. Installa il AWS Load Balancer Controller. Sostituisci il valore 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 ed esegui il comando seguente. 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. [Controller del bilanciatore del carico AWS](hybrid-nodes-webhooks.md#hybrid-nodes-mixed-lbc)
+ Puoi trovare la versione più recente del grafico Helm eseguendo `helm search repo eks/aws-load-balancer-controller --versions`.
```
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 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
```
1. Crea un’applicazione di esempio. L’esempio seguente utilizza l’applicazione di microservizi di esempio [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Crea un file denominato `my-ingress-alb.yaml` con i seguenti contenuti.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
namespace: default
annotations:
alb.ingress.kubernetes.io/load-balancer-name: "my-ingress-alb"
alb.ingress.kubernetes.io/target-type: "ip"
alb.ingress.kubernetes.io/scheme: "internet-facing"
alb.ingress.kubernetes.io/healthcheck-path: "/details/1"
spec:
ingressClassName: alb
rules:
- http:
paths:
- backend:
service:
name: details
port:
number: 9080
path: /details
pathType: Prefix
```
1. Applica la configurazione dell’ingresso al cluster.
```
kubectl apply -f my-ingress-alb.yaml
```
1. Il provisioning dell’ALB per la risorsa in ingresso può richiedere alcuni minuti. Una volta effettuato il provisioning dell’ALB, alla risorsa Ingress verrà assegnato un indirizzo che corrisponde al nome DNS dell’implementazione ALB. L’indirizzo avrà il formato `-..elb.amazonaws.com`.
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress alb * my-ingress-alb-..elb.amazonaws.com 80 23m
```
1. Accedi al Servizio utilizzando l’indirizzo dell’ALB.
```
curl -s http//my-ingress-alb-..elb.amazonaws.com:80/details/1 | jq
```
```
{
"id": 1,
"author": "William Shakespeare",
"year": 1595,
"type": "paperback",
"pages": 200,
"publisher": "PublisherA",
"language": "English",
"ISBN-10": "1234567890",
"ISBN-13": "123-1234567890"
"details": "This is the details page"
}
```
## Panoramica dell’ingresso di Cilium e del gateway di Cilium
Le funzionalità dell’ingresso di Cilium sono integrate nell’architettura di Cilium e possono essere gestite con l’API dell’ingresso di Kubernetes o l’API Gateway. Se non disponi di risorse Ingress esistenti, ti consigliamo di AWS iniziare con l'API Gateway, poiché è un modo più espressivo e flessibile per definire e gestire le risorse di rete Kubernetes. L’[API del Gateway di Kubernetes](https://gateway-api.sigs.k8s.io/) mira a standardizzare il modo in cui le risorse di rete per ingresso, bilanciamento del carico e mesh di servizi vengono definite e gestite nei cluster Kubernetes.
Quando abiliti le funzionalità di ingresso o gateway di Cilium, l’operatore Cilium riconcilia gli oggetti ingresso/gateway nel cluster e i proxy Envoy su ciascun nodo elaborano il traffico di rete di livello 7 (L7). Cilium non fornisce direttamente l’infrastruttura ingresso/gateway come i bilanciatori del carico. Se prevedi di utilizzare l’ingresso/gateway di Cilium con un bilanciatore del carico, devi utilizzare gli strumenti di quest’ultimo, in genere un controller di ingresso o gateway, per distribuire e gestire l’infrastruttura del sistema del bilanciatore del carico.
Per il traffico ingresso/gateway, Cilium gestisce il traffico di rete principale e l’applicazione delle policy L3/L4, mentre i proxy Envoy integrati elaborano il traffico di rete L7. Con l’ingresso/gateway di Cilium, Envoy è responsabile dell’applicazione delle regole di routing L7, delle policy e della manipolazione delle richieste, della gestione avanzata del traffico come la suddivisione e il mirroring del traffico e della terminazione e origine del TLS. I proxy Envoy di Cilium vengono distribuiti come proxy separati DaemonSet (`cilium-envoy`) per impostazione predefinita, il che consente a Envoy e all'agente Cilium di essere aggiornati, scalati e gestiti separatamente.
Per ulteriori informazioni su come funzionano l’ingresso di Cilium e il gateway di Cilium, consulta le pagine [Cilium Ingress](https://docs.cilium.io/en/stable/network/servicemesh/ingress/) e [Cilium Gateway](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/) nella documentazione di Cilium.
## Confronto tra ingresso e gateway di Cilium
La tabella seguente riassume le funzionalità di ingresso e gateway di Cilium, a partire dalla **versione 1.17.x di Cilium**.
| Funzionalità | Ingresso | Gateway |
| --- | --- | --- |
| Tipo di servizio LoadBalancer | Sì | Sì |
| Tipo di servizio NodePort | Sì | No1 |
| Rete host | Sì | Sì |
| Bilanciatore del carico condiviso | Sì | Sì |
| Bilanciatore del carico dedicato | Sì | No2 |
| Policy di rete | Sì | Sì |
| Protocolli | Livello 7 (HTTP(S), gRPC) | Livello 7 (HTTP(S), gRPC)3 |
| TLS Passthrough | Sì | Sì |
| Gestione del traffico | Routing del percorso e dell’host | Routing del percorso e dell’host, reindirizzamento e riscrittura degli URL, suddivisione del traffico, modifica dell’intestazione |
1 [Il supporto per i NodePort servizi di Cilium Gateway è previsto per la versione 1.18.x di Cilium (\#27273)](https://github.com/cilium/cilium/pull/27273)
2 Supporto del gateway di Cilium per bilanciatori del carico dedicati ([\#25567](https://github.com/cilium/cilium/issues/25567))
3 Supporto [Cilium Gateway per (\#21929) TCP/UDP ](https://github.com/cilium/cilium/issues/21929)
## Installazione del gateway di Cilium
### Considerazioni
+ Cilium deve essere configurato con `nodePort.enabled` impostato su `true` come mostrato negli esempi seguenti. Se utilizzi la funzionalità di sostituzione kube-proxy di Cilium, non devi impostare `nodePort.enabled` su `true`.
+ Cilium deve essere configurato con `envoy.enabled` impostato su `true` come mostrato negli esempi seguenti.
+ Il gateway di Cilium può essere distribuito nel bilanciatore del carico (impostazione predefinita) o in modalità rete host.
+ Quando si utilizza Cilium Gateway in modalità load balancer, l'`service.beta.kubernetes.io/aws-load-balancer-type: "external"`annotazione deve essere impostata sulla risorsa Gateway per impedire al provider AWS cloud legacy di creare un Classic Load Balancer for the Service del LoadBalancer tipo che Cilium crea per la risorsa Gateway.
+ Quando si utilizza Cilium Gateway in modalità rete host, la modalità Service of type è disabilitata. LoadBalancer La modalità di rete host è utile per gli ambienti che non dispongono di un’infrastruttura del bilanciatore del carico; per ulteriori informazioni, consulta [Rete host](#hybrid-nodes-ingress-cilium-host-network).
### Prerequisiti
1. Helm è installato nell’ambiente a riga di comando, consulta [Setup Helm instructions](helm.md).
1. Cilium è installato seguendo le istruzioni contenute in [Configurazione della CNI per nodi ibridi](hybrid-nodes-cni.md).
### Procedura
1. Installa le definizioni delle risorse personalizzate dell'API Kubernetes Gateway (). CRDs
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gatewayclasses.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gateways.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_httproutes.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_referencegrants.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_grpcroutes.yaml
```
1. Crea un file denominato `cilium-gateway-values.yaml` con i seguenti contenuti. L'esempio seguente configura Cilium Gateway per utilizzare la modalità di bilanciamento del carico predefinita e per utilizzare un proxy Envoy separato configurato `cilium-envoy` DaemonSet per l'esecuzione solo su nodi ibridi.
```
gatewayAPI:
enabled: true
# uncomment to use host network mode
# hostNetwork:
# enabled: true
nodePort:
enabled: true
envoy:
enabled: true
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: eks.amazonaws.com/compute-type
operator: In
values:
- hybrid
```
1. Applica il file di valori Helm al cluster.
```
helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
--namespace kube-system \
--reuse-values \
--set operator.rollOutPods=true \
--values cilium-gateway-values.yaml
```
1. Verifica che l’operatore, l’agente e i pod Envoy Cilium siano in esecuzione.
```
kubectl -n kube-system get pods --selector=app.kubernetes.io/part-of=cilium
```
```
NAME READY STATUS RESTARTS AGE
cilium-envoy-5pgnd 1/1 Running 0 6m31s
cilium-envoy-6fhg4 1/1 Running 0 6m30s
cilium-envoy-jskrk 1/1 Running 0 6m30s
cilium-envoy-k2xtb 1/1 Running 0 6m31s
cilium-envoy-w5s9j 1/1 Running 0 6m31s
cilium-grwlc 1/1 Running 0 4m12s
cilium-operator-68f7766967-5nnbl 1/1 Running 0 4m20s
cilium-operator-68f7766967-7spfz 1/1 Running 0 4m20s
cilium-pnxcv 1/1 Running 0 6m29s
cilium-r7qkj 1/1 Running 0 4m12s
cilium-wxhfn 1/1 Running 0 4m1s
cilium-z7hlb 1/1 Running 0 6m30s
```
## Configurazione del gateway di Cilium
Il gateway di Cilium è abilitato sugli oggetti del gateway impostando `gatewayClassName` su `cilium`. Il servizio creato da Cilium per le risorse del gateway può essere configurato con campi sull’oggetto del gateway. Le annotazioni comuni utilizzate dai controller del gateway per configurare l’infrastruttura del bilanciatore del carico possono essere configurate con il campo `infrastructure` dell’oggetto del gateway. Quando si utilizza l' LoadBalancer IPAM di Cilium (vedi esempio in[Tipo di servizio LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer)), l'indirizzo IP da utilizzare per il Service of type LoadBalancer può essere configurato nel campo dell'oggetto Gateway. `addresses` Per ulteriori informazioni sulla configurazione del gateway, consulta [Kubernetes Gateway API specification](https://gateway-api.sigs.k8s.io/reference/spec/#gateway).
```
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
name: my-gateway
spec:
gatewayClassName: cilium
infrastructure:
annotations:
service.beta.kubernetes.io/...
service.kubernetes.io/...
addresses:
- type: IPAddress
value:
listeners:
...
```
Cilium e le specifiche Kubernetes Gateway supportano, Gateway GatewayClass, e le risorse. HTTPRoute GRPCRoute ReferenceGrant
+ Vedi [HTTPRoute](https://gateway-api.sigs.k8s.io/api-types/httproute/HTTPRoute)e [GRPCRoute](https://gateway-api.sigs.k8s.io/api-types/grpcroute/GRPCRoute)specifiche per l'elenco dei campi disponibili.
+ Vedi gli esempi nella sezione [Implementazione del gateway di Cilium](#hybrid-nodes-ingress-cilium-gateway-deploy) seguente e gli esempi in [Cilium documentation](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#examples) per scoprire come utilizzare e configurare queste risorse.
## Implementazione del gateway di Cilium
1. Crea un’applicazione di esempio. L’esempio seguente utilizza l’applicazione di microservizi di esempio [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Verifica che l’applicazione sia in esecuzione correttamente.
```
kubectl get pods
```
```
NAME READY STATUS RESTARTS AGE
details-v1-766844796b-9965p 1/1 Running 0 81s
productpage-v1-54bb874995-jmc8j 1/1 Running 0 80s
ratings-v1-5dc79b6bcd-smzxz 1/1 Running 0 80s
reviews-v1-598b896c9d-vj7gb 1/1 Running 0 80s
reviews-v2-556d6457d-xbt8v 1/1 Running 0 80s
reviews-v3-564544b4d6-cpmvq 1/1 Running 0 80s
```
1. Crea un file denominato `my-gateway.yaml` con i seguenti contenuti. L'esempio seguente utilizza l'`service.beta.kubernetes.io/aws-load-balancer-type: "external"`annotazione per impedire al provider AWS cloud legacy di creare un Classic Load Balancer per il servizio del LoadBalancer tipo creato da Cilium per la risorsa Gateway.
```
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
name: my-gateway
spec:
gatewayClassName: cilium
infrastructure:
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: "external"
listeners:
- protocol: HTTP
port: 80
name: web-gw
allowedRoutes:
namespaces:
from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: http-app-1
spec:
parentRefs:
- name: my-gateway
namespace: default
rules:
- matches:
- path:
type: PathPrefix
value: /details
backendRefs:
- name: details
port: 9080
```
1. Applica la risorsa del gateway al cluster.
```
kubectl apply -f my-gateway.yaml
```
1. Conferma che la risorsa del gateway e il servizio corrispondente sono stati creati. In questa fase, si prevede che il `ADDRESS` campo della risorsa Gateway non sia popolato con un indirizzo IP o un nome host e che al servizio di tipo LoadBalancer relativo alla risorsa Gateway non sia assegnato un indirizzo IP o un nome host.
```
kubectl get gateway my-gateway
```
```
NAME CLASS ADDRESS PROGRAMMED AGE
my-gateway cilium True 10s
```
```
kubectl get svc cilium-gateway-my-gateway
```
```
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
cilium-gateway-my-gateway LoadBalancer 172.16.227.247 80:30912/TCP 24s
```
1. Procedi [Tipo di servizio LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer) alla configurazione della risorsa Gateway per utilizzare un indirizzo IP allocato da Cilium Load Balancer IPAM [Rete host](#hybrid-nodes-ingress-cilium-host-network) e/o alla configurazione della risorsa Gateway per NodePort utilizzare o ospitare indirizzi di rete. [Tipo di servizio NodePort](#hybrid-nodes-ingress-cilium-nodeport)
## Installazione dell’ingresso di Cilium
### Considerazioni
+ Cilium deve essere configurato con `nodePort.enabled` impostato su `true` come mostrato negli esempi seguenti. Se utilizzi la funzionalità di sostituzione kube-proxy di Cilium, non devi impostare `nodePort.enabled` su `true`.
+ Cilium deve essere configurato con `envoy.enabled` impostato su `true` come mostrato negli esempi seguenti.
+ Con `ingressController.loadbalancerMode` impostato su `dedicated`, Cilium crea servizi dedicati per ogni risorsa dell’ingresso. Con `ingressController.loadbalancerMode` set to`shared`, Cilium crea un servizio condiviso di tipo LoadBalancer per tutte le risorse Ingress nel cluster. Quando si utilizza la modalità del bilanciatore del carico `shared`, le impostazioni per il servizio condiviso come `labels`, `annotations`, `type` e `loadBalancerIP` sono configurate nella sezione dei valori Helm `ingressController.service`. Per ulteriori informazioni, consulta [Cilium Helm values reference](https://github.com/cilium/cilium/blob/v1.17.6/install/kubernetes/cilium/values.yaml#L887).
+ Con `ingressController.default` impostato su `true`, Cilium è configurato come controller di ingresso predefinito per il cluster e creerà voci di ingresso anche quando `ingressClassName` non è specificato nelle risorse di ingresso.
+ L’ingresso di Cilium può essere distribuito nel bilanciatore del carico (impostazione predefinita), nella porta del nodo o in modalità rete host. Quando Cilium è installato in modalità rete host, le modalità Servizio di tipo LoadBalancer e Servizio di tipo NodePort sono disabilitate. Per ulteriori informazioni, consulta [Rete host](#hybrid-nodes-ingress-cilium-host-network).
+ Imposta sempre su `ingressController.service.annotations` `service.beta.kubernetes.io/aws-load-balancer-type: "external"` nei valori Helm per impedire al provider AWS cloud legacy di creare un Classic Load Balancer per il servizio `cilium-ingress` predefinito creato dal grafico [Cilium](https://github.com/cilium/cilium/blob/main/install/kubernetes/cilium/templates/cilium-ingress-service.yaml) Helm.
### Prerequisiti
1. Helm è installato nell’ambiente a riga di comando, consulta [Setup Helm instructions](helm.md).
1. Cilium è installato seguendo le istruzioni contenute in [Configurazione della CNI per nodi ibridi](hybrid-nodes-cni.md).
### Procedura
1. Crea un file denominato `cilium-ingress-values.yaml` con i seguenti contenuti. L'esempio seguente configura Cilium Ingress per utilizzare la `dedicated` modalità di bilanciamento del carico predefinita e per utilizzare un proxy separato `cilium-envoy` DaemonSet per Envoy configurato per l'esecuzione solo su nodi ibridi.
```
ingressController:
enabled: true
loadbalancerMode: dedicated
service:
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: "external"
nodePort:
enabled: true
envoy:
enabled: true
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: eks.amazonaws.com/compute-type
operator: In
values:
- hybrid
```
1. Applica il file di valori Helm al cluster.
```
helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
--namespace kube-system \
--reuse-values \
--set operator.rollOutPods=true \
--values cilium-ingress-values.yaml
```
1. Verifica che l’operatore, l’agente e i pod Envoy Cilium siano in esecuzione.
```
kubectl -n kube-system get pods --selector=app.kubernetes.io/part-of=cilium
```
```
NAME READY STATUS RESTARTS AGE
cilium-envoy-5pgnd 1/1 Running 0 6m31s
cilium-envoy-6fhg4 1/1 Running 0 6m30s
cilium-envoy-jskrk 1/1 Running 0 6m30s
cilium-envoy-k2xtb 1/1 Running 0 6m31s
cilium-envoy-w5s9j 1/1 Running 0 6m31s
cilium-grwlc 1/1 Running 0 4m12s
cilium-operator-68f7766967-5nnbl 1/1 Running 0 4m20s
cilium-operator-68f7766967-7spfz 1/1 Running 0 4m20s
cilium-pnxcv 1/1 Running 0 6m29s
cilium-r7qkj 1/1 Running 0 4m12s
cilium-wxhfn 1/1 Running 0 4m1s
cilium-z7hlb 1/1 Running 0 6m30s
```
## Configurazione dell’ingresso di Cilium
L’ingresso di Cilium è abilitato sugli oggetti dell’ingresso impostando `ingressClassName` su `cilium`. I servizi che Cilium crea per le risorse dell’ingresso possono essere configurati con annotazioni sugli oggetti dell’ingresso quando si utilizza la modalità del bilanciatore del carico `dedicated` e nella configurazione Cilium/Helm quando si utilizza la modalità del bilanciatore del carico `shared`. Queste annotazioni vengono comunemente utilizzate dai controller dell’ingresso per configurare l’infrastruttura del bilanciatore del carico o altri attributi del Servizio come il tipo di servizio, la modalità del bilanciatore del carico, le porte e il passthrough TLS. Le annotazioni chiave sono descritte di seguito. Per un elenco completo delle annotazioni supportate, consulta [Cilium Ingress annotations](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#supported-ingress-annotations) nella documentazione di Cilium.
| Annotazione | Description |
| --- | --- |
| `ingress.cilium.io/loadbalancer-mode` | `dedicated`: Servizio dedicato di tipo LoadBalancer per ogni risorsa Ingress (impostazione predefinita).
`shared`: Servizio unico di tipo LoadBalancer per tutte le risorse Ingress. |
| `ingress.cilium.io/service-type` | `LoadBalancer`: Il servizio sarà di tipo LoadBalancer (impostazione predefinita)
`NodePort`: Il servizio sarà di tipo NodePort. |
| `service.beta.kubernetes.io/aws-load-balancer-type` | `"external"`: Impedisci ai provider di AWS cloud legacy di effettuare il provisioning di Classic Load Balancer for Services di tipo Classic Load Balancer for Services. LoadBalancer |
| `lbipam.cilium.io/ips` | Elenco di indirizzi IP da allocare da Cilium IPAM LoadBalancer |
Cilium e le specifiche dell’ingresso di Kubernetes supportano regole di corrispondenza specifiche per Exact, Prefix e Implementation per i percorsi dell’ingresso. Cilium supporta l’espressione regolare come regola di corrispondenza specifica per l’implementazione. Per ulteriori informazioni, consulta [Ingress path types and precedence](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#ingress-path-types-and-precedence) e [Path types examples](https://docs.cilium.io/en/stable/network/servicemesh/path-types/) nella documentazione di Cilium e gli esempi nella sezione [Implementazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy) di questa pagina.
Un esempio di oggetto dell’ingresso di Cilium è mostrato di seguito.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
annotations:
service.beta.kubernetes.io/...
service.kubernetes.io/...
spec:
ingressClassName: cilium
rules:
...
```
## Implementazione dell’ingresso di Cilium
1. Crea un’applicazione di esempio. L’esempio seguente utilizza l’applicazione di microservizi di esempio [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Verifica che l’applicazione sia in esecuzione correttamente.
```
kubectl get pods
```
```
NAME READY STATUS RESTARTS AGE
details-v1-766844796b-9965p 1/1 Running 0 81s
productpage-v1-54bb874995-jmc8j 1/1 Running 0 80s
ratings-v1-5dc79b6bcd-smzxz 1/1 Running 0 80s
reviews-v1-598b896c9d-vj7gb 1/1 Running 0 80s
reviews-v2-556d6457d-xbt8v 1/1 Running 0 80s
reviews-v3-564544b4d6-cpmvq 1/1 Running 0 80s
```
1. Crea un file denominato `my-ingress.yaml` con i seguenti contenuti. L'esempio seguente utilizza l'`service.beta.kubernetes.io/aws-load-balancer-type: "external"`annotazione per impedire al provider AWS cloud legacy di creare un Classic Load Balancer per il servizio del LoadBalancer tipo creato da Cilium per la risorsa Ingress.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
namespace: default
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: "external"
spec:
ingressClassName: cilium
rules:
- http:
paths:
- backend:
service:
name: details
port:
number: 9080
path: /details
pathType: Prefix
```
1. Applica la risorsa dell’ingresso al cluster.
```
kubectl apply -f my-ingress.yaml
```
1. Conferma che la risorsa dell’ingresso e il servizio corrispondente sono stati creati. In questa fase, si prevede che il `ADDRESS` campo della risorsa Ingress non sia popolato con un indirizzo IP o un nome host e che analogamente al servizio condiviso o dedicato LoadBalancer per la risorsa Ingress non sia assegnato un indirizzo IP o un nome host.
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress cilium * 80 8s
```
Per la modalità del bilanciatore del carico `shared`
```
kubectl -n kube-system get svc cilium-ingress
```
```
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
cilium-ingress LoadBalancer 172.16.217.48 80:32359/TCP,443:31090/TCP 10m
```
Per la modalità del bilanciatore del carico `dedicated`
```
kubectl -n default get svc cilium-ingress-my-ingress
```
```
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
cilium-ingress-my-ingress LoadBalancer 172.16.193.15 80:32088/TCP,443:30332/TCP 25s
```
1. Procedi [Tipo di servizio LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer) alla configurazione della risorsa Ingress per utilizzare un indirizzo IP allocato da Cilium Load Balancer IPAM [Tipo di servizio NodePort](#hybrid-nodes-ingress-cilium-nodeport) e/o [Rete host](#hybrid-nodes-ingress-cilium-host-network) alla configurazione della risorsa Ingress per utilizzare o ospitare gli indirizzi di rete. NodePort
## Tipo di servizio LoadBalancer
### Infrastruttura del bilanciatore del carico esistente
Per impostazione predefinita, sia per Cilium Ingress che per Cilium Gateway, Cilium crea uno o più servizi Kubernetes di tipo LoadBalancer per le risorse Ingress/Gateway. Gli attributi dei Servizi creati da Cilium possono essere configurati tramite le risorse dell’ingresso e del gateway. Quando crei risorse ingresso o gateway, l’indirizzo IP o i nomi host esposti esternamente per ingresso o gateway vengono allocati dall’infrastruttura del bilanciatore del carico, che in genere viene fornita da un controller di ingresso o gateway.
Molti controller dell’ingresso e del gateway utilizzano le annotazioni per rilevare e configurare l’infrastruttura del bilanciatore del carico. Le annotazioni per questi controller dell’ingresso e del gateway sono configurate sulle risorse dell’ingresso o del gateway come mostrato negli esempi precedenti. Fai riferimento alla documentazione del controller dell’ingresso o del gateway per le annotazioni che supporta e consulta [Kubernetes Ingress documentation](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/) e [Kubernetes Gateway documentation](https://gateway-api.sigs.k8s.io/implementations/) per un elenco dei controller più diffusi.
**Importante**
Cilium Ingress and Gateway non possono essere utilizzati con Load AWS Balancer Controller AWS e Network Load Balancer NLBs () con EKS Hybrid Nodes. Il tentativo di utilizzarli insieme porta a obiettivi non registrati, poiché l'NLB tenta di connettersi direttamente al Pod IPs che supporta il tipo di servizio LoadBalancer quando l'NLB `target-type` è impostato su `ip` (requisito per l'utilizzo di NLB con carichi di lavoro in esecuzione su nodi ibridi EKS).
### Nessuna infrastruttura del bilanciatore del carico
Se non si dispone di un'infrastruttura di bilanciamento del carico e del corrispondente controller Ingress/Gateway nel proprio ambiente, è LoadBalancer possibile configurare le risorse Ingress/Gateway e i servizi di tipo corrispondente per utilizzare gli indirizzi IP allocati dalla gestione degli indirizzi IP Load [Balancer](https://docs.cilium.io/en/stable/network/lb-ipam/) (LB IPAM) di Cilium. Cilium LB IPAM può essere configurato con intervalli di indirizzi IP noti dall'ambiente locale e può utilizzare il supporto Border Gateway Protocol (BGP) integrato di Cilium o gli annunci L2 per pubblicizzare gli indirizzi LoadBalancer IP sulla rete locale.
L'esempio seguente mostra come configurare l'IPAM LB di Cilium con un indirizzo IP da utilizzare per le risorse Ingress/Gateway e come configurare Cilium BGP Control Plane per pubblicizzare l'indirizzo LoadBalancer IP con la rete locale. La funzionalità LB IPAM di Cilium è abilitata per impostazione predefinita, ma non viene attivata finché non viene creata una risorsa `CiliumLoadBalancerIPPool`.
#### Prerequisiti
+ Ingresso e gateway di Cilium installati seguendo le istruzioni in [Installazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-install) o [Installazione del gateway di Cilium](#hybrid-nodes-ingress-cilium-gateway-install).
+ Risorse dell’ingresso o del gateway di Cilium con applicazione di esempio distribuita seguendo le istruzioni in [Implementazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy) o [Implementazione del gateway di Cilium](#hybrid-nodes-ingress-cilium-gateway-deploy).
+ 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, puoi saltare questo prerequisito, ma non sarai in grado di accedere alla tua risorsa Ingress o Gateway finché l'indirizzo LoadBalancer IP assegnato da Cilium LB IPAM non sarà instradabile sulla tua rete locale.
#### Procedura
1. Facoltativamente, applica una patch alla risorsa Ingress o Gateway per richiedere un indirizzo IP specifico da utilizzare per il tipo di servizio. LoadBalancer Se non richiedi un indirizzo IP specifico, Cilium ne assegnerà uno dall’intervallo di indirizzi IP configurato nella risorsa `CiliumLoadBalancerIPPool` nel passaggio successivo. Nei comandi seguenti, sostituiscilo `LB_IP_ADDRESS` con l'indirizzo IP per richiedere il tipo di servizio. LoadBalancer
**Gateway**
```
kubectl patch gateway -n default my-gateway --type=merge -p '{
"spec": {
"addresses": [{"type": "IPAddress", "value": "LB_IP_ADDRESS"}]
}
}'
```
**Ingresso**
```
kubectl patch ingress my-ingress --type=merge -p '{
"metadata": {"annotations": {"lbipam.cilium.io/ips": "LB_IP_ADDRESS"}}
}'
```
1. Crea un file denominato `cilium-lbip-pool-ingress.yaml` con una risorsa `CiliumLoadBalancerIPPool` per configurare l’intervallo di indirizzi IP del bilanciatore del carico per le tue risorse ingresso/gateway.
+ Se utilizzi l’ingresso di Cilium, Cilium applica automaticamente l’etichetta `cilium.io/ingress: "true"` ai Servizi che crea per le risorse dell’ingresso. Puoi utilizzare questa etichetta nel campo `serviceSelector` della definizione delle risorse `CiliumLoadBalancerIPPool` per selezionare i Servizi idonei per LB IPAM.
+ Se utilizzi il gateway di Cilium, puoi usare l’etichetta `gateway.networking.k8s.io/gateway-name` nei campi `serviceSelector` della definizione delle risorse per selezionare le risorse `CiliumLoadBalancerIPPool` gateway idonee per LB IPAM.
+ 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 [Gestione degli indirizzi LoadBalancer IP](https://docs.cilium.io/en/stable/network/lb-ipam/) nella documentazione di Cilium.
```
apiVersion: cilium.io/v2alpha1
kind: CiliumLoadBalancerIPPool
metadata:
name: bookinfo-pool
spec:
blocks:
- cidr: "LB_IP_CIDR"
serviceSelector:
# if using Cilium Gateway
matchExpressions:
- { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
# if using Cilium Ingress
matchLabels:
cilium.io/ingress: "true"
```
1. Applica la risorsa `CiliumLoadBalancerIPPool` al cluster.
```
kubectl apply -f cilium-lbip-pool-ingress.yaml
```
1. Conferma che un indirizzo IP è stato allocato da Cilium LB IPAM per la risorsa dell’ingresso/gateway.
**Gateway**
```
kubectl get gateway my-gateway
```
```
NAME CLASS ADDRESS PROGRAMMED AGE
my-gateway cilium {{LB_IP_ADDRESS}} True 6m41s
```
**Ingresso**
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress cilium * {{LB_IP_ADDRESS}} 80 10m
```
1. Crea un file denominato `cilium-bgp-advertisement-ingress.yaml` con una `CiliumBGPAdvertisement` risorsa per pubblicizzare l'indirizzo LoadBalancer IP per le risorse Ingress/Gateway. Se non utilizzi un BGP di Cilium, puoi ignorare questo passaggio. L'indirizzo LoadBalancer IP utilizzato per la risorsa Ingress/Gateway deve essere instradabile sulla rete locale per poter interrogare il servizio nel passaggio successivo.
```
apiVersion: cilium.io/v2alpha1
kind: CiliumBGPAdvertisement
metadata:
name: bgp-advertisement-lb-ip
labels:
advertise: bgp
spec:
advertisements:
- advertisementType: "Service"
service:
addresses:
- LoadBalancerIP
selector:
# if using Cilium Gateway
matchExpressions:
- { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
# if using Cilium Ingress
matchLabels:
cilium.io/ingress: "true"
```
1. Applica la risorsa `CiliumBGPAdvertisement` al cluster.
```
kubectl apply -f cilium-bgp-advertisement-ingress.yaml
```
1. Accedi al servizio utilizzando l’indirizzo IP assegnato da Cilium LB IPAM.
```
curl -s http://{{LB_IP_ADDRESS}}:80/details/1 | jq
```
```
{
"id": 1,
"author": "William Shakespeare",
"year": 1595,
"type": "paperback",
"pages": 200,
"publisher": "PublisherA",
"language": "English",
"ISBN-10": "1234567890",
"ISBN-13": "123-1234567890"
}
```
## Tipo di servizio NodePort
Se non disponi di un'infrastruttura di bilanciamento del carico e del corrispondente controller Ingress nel tuo ambiente, o se gestisci autonomamente l'infrastruttura di bilanciamento del carico o utilizzi il bilanciamento del carico basato su DNS, puoi configurare Cilium Ingress per creare servizi di tipo per le risorse Ingress. NodePort Quando si utilizza NodePort con Cilium Ingress, il tipo di servizio è esposto su una porta su ciascun nodo nell'intervallo di porte NodePort 30000-32767. In questa modalità, quando il traffico raggiunge qualsiasi nodo del cluster sul NodePort, viene quindi inoltrato a un pod che supporta il servizio, che può trovarsi sullo stesso nodo o su un nodo diverso.
**Nota**
[Il supporto per i NodePort servizi di Cilium Gateway è previsto per la versione 1.18.x di Cilium (\#27273)](https://github.com/cilium/cilium/pull/27273)
### Prerequisiti
+ Ingresso di Cilium installato seguendo le istruzioni in [Installazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-install).
+ Risorse dell’ingresso di Cilium con applicazione di esempio distribuita seguendo le istruzioni in [Implementazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy).
### Procedura
1. Aggiorna la risorsa Ingress esistente `my-ingress` per cambiarla da Tipo di servizio a. LoadBalancer NodePort
```
kubectl patch ingress my-ingress --type=merge -p '{
"metadata": {"annotations": {"ingress.cilium.io/service-type": "NodePort"}}
}'
```
Se non hai creato la risorsa dell’ingresso, puoi crearla applicando la seguente definizione dell’ingresso al tuo cluster. Nota, la definizione dell’ingresso riportata di seguito utilizza l’applicazione di esempio Istio Bookinfo descritta in [Implementazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy).
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
namespace: default
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: "external"
"ingress.cilium.io/service-type": "NodePort"
spec:
ingressClassName: cilium
rules:
- http:
paths:
- backend:
service:
name: details
port:
number: 9080
path: /details
pathType: Prefix
```
1. Conferma che il servizio per la risorsa Ingress è stato aggiornato per utilizzare il tipo di servizio. NodePort Nota la porta per il protocollo HTTP nell’output. Nell’esempio seguente, questa è la porta HTTP `32353`, che verrà utilizzata in un passaggio successivo per interrogare il servizio. Il vantaggio dell'utilizzo di Cilium Ingress with Service of type NodePort è che è possibile applicare il routing basato su percorsi e host, nonché politiche di rete per il traffico in ingresso, cosa che non è possibile eseguire per un servizio standard di tipo senza Ingress. NodePort
```
kubectl -n default get svc cilium-ingress-my-ingress
```
```
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
cilium-ingress-my-ingress NodePort 172.16.47.153 80:32353/TCP,443:30253/TCP 27m
```
1. Ottieni l’indirizzo IP dei nodi nel cluster.
```
kubectl get nodes -o wide
```
```
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
mi-026d6a261e355fba7 Ready 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. Accedi al tipo di servizio NodePort utilizzando gli indirizzi IP dei tuoi nodi e quelli acquisiti in precedenza. NodePort Nell'esempio seguente l'indirizzo IP del nodo utilizzato è `10.80.146.32` e lo NodePort è`32353`. Sostituisci questi valori per il tuo ambiente.
```
curl -s http://10.80.146.32:32353/details/1 | jq
```
```
{
"id": 1,
"author": "William Shakespeare",
"year": 1595,
"type": "paperback",
"pages": 200,
"publisher": "PublisherA",
"language": "English",
"ISBN-10": "1234567890",
"ISBN-13": "123-1234567890"
}
```
## Rete host
Analogamente al tipo di servizio NodePort, se non si dispone di un'infrastruttura di bilanciamento del carico e di un controller Ingress o Gateway, o se si gestisce autonomamente il bilanciamento del carico con un bilanciamento del carico esterno, è possibile configurare Cilium Ingress e Cilium Gateway per esporre le risorse Ingress e Gateway direttamente sulla rete host. Quando la modalità di rete host è abilitata per una risorsa Ingress o Gateway, il tipo LoadBalancer e le NodePort modalità del Servizio vengono automaticamente disabilitati, la modalità di rete host si esclude a vicenda con queste modalità alternative per ogni risorsa Ingress o Gateway. Rispetto alla NodePort modalità Service of type, la modalità di rete host offre una flessibilità aggiuntiva per la gamma di porte che possono essere utilizzate (non è limitata alla NodePort gamma 30000-32767) ed è possibile configurare un sottoinsieme di nodi in cui i proxy Envoy vengono eseguiti sulla rete host.
### Prerequisiti
+ Ingresso e gateway di Cilium installati seguendo le istruzioni in [Installazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-install) o [Installazione del gateway di Cilium](#hybrid-nodes-ingress-cilium-gateway-install).
### Procedura
#### Gateway
1. Crea un archivio denominato `cilium-gateway-host-network.yaml` con i seguenti contenuti.
```
gatewayAPI:
enabled: true
hostNetwork:
enabled: true
# uncomment to restrict nodes where Envoy proxies run on the host network
# nodes:
# matchLabels:
# role: gateway
```
1. Applica la configurazione del gateway di Cilium della rete host al cluster.
```
helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
--namespace kube-system \
--reuse-values \
--set operator.rollOutPods=true \
-f cilium-gateway-host-network.yaml
```
Se non hai creato la risorsa del gateway, puoi crearla applicando la seguente definizione di gateway al tuo cluster. La definizione del gateway riportata di seguito utilizza l’applicazione di esempio Istio Bookinfo descritta in [Implementazione del gateway di Cilium](#hybrid-nodes-ingress-cilium-gateway-deploy). Nell’esempio seguente, la risorsa del gateway è configurata per utilizzare la porta `8111` per il listener HTTP, che è la porta listener condivisa per i proxy Envoy in esecuzione sulla rete host. Se stai utilizzando una porta privilegiata (inferiore a 1023) per la risorsa del gateway, fai riferimento a [Cilium documentation](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#bind-to-privileged-port) per le istruzioni.
```
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
name: my-gateway
spec:
gatewayClassName: cilium
listeners:
- protocol: HTTP
port: 8111
name: web-gw
allowedRoutes:
namespaces:
from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: http-app-1
spec:
parentRefs:
- name: my-gateway
namespace: default
rules:
- matches:
- path:
type: PathPrefix
value: /details
backendRefs:
- name: details
port: 9080
```
Puoi osservare la configurazione Cilium Envoy applicata con il seguente comando.
```
kubectl get cec cilium-gateway-my-gateway -o yaml
```
Puoi ottenere la porta del listener Envoy per il servizio `cilium-gateway-my-gateway` con il seguente comando. In questo esempio, la porta del listener condiviso è `8111`.
```
kubectl get cec cilium-gateway-my-gateway -o jsonpath={.spec.services[0].ports[0]}
```
1. Ottieni l’indirizzo IP dei nodi nel cluster.
```
kubectl get nodes -o wide
```
```
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
mi-026d6a261e355fba7 Ready 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. Accedi al servizio utilizzando gli indirizzi IP dei nodi e la porta del listener per la risorsa `cilium-gateway-my-gateway`. Nell’esempio seguente l’indirizzo IP del nodo utilizzato è `10.80.146.32` e la porta del listener è `8111`. Sostituisci questi valori per il tuo ambiente.
```
curl -s http://10.80.146.32:8111/details/1 | jq
```
```
{
"id": 1,
"author": "William Shakespeare",
"year": 1595,
"type": "paperback",
"pages": 200,
"publisher": "PublisherA",
"language": "English",
"ISBN-10": "1234567890",
"ISBN-13": "123-1234567890"
}
```
#### Ingresso
A causa di un problema con Cilium upstream ([\#34028](https://github.com/cilium/cilium/issues/34028)), l’ingresso di Cilium in modalità rete host richiede l’utilizzo di `loadbalancerMode: shared`, che crea un unico servizio di tipo ClusterIP per tutte le risorse dell’ingresso nel cluster. Se stai utilizzando una porta privilegiata (inferiore a 1023) per la risorsa dell’ingresso, fai riferimento a [Cilium documentation](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#bind-to-privileged-port) per le istruzioni.
1. Crea un archivio denominato `cilium-ingress-host-network.yaml` con i seguenti contenuti.
```
ingressController:
enabled: true
loadbalancerMode: shared
# This is a workaround for the upstream Cilium issue
service:
externalTrafficPolicy: null
type: ClusterIP
hostNetwork:
enabled: true
# ensure the port does not conflict with other services on the node
sharedListenerPort: 8111
# uncomment to restrict nodes where Envoy proxies run on the host network
# nodes:
# matchLabels:
# role: ingress
```
1. Applica la configurazione dell’ingresso di Cilium della rete host al tuo cluster.
```
helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
--namespace kube-system \
--reuse-values \
--set operator.rollOutPods=true \
-f cilium-ingress-host-network.yaml
```
Se non hai creato la risorsa dell’ingresso, puoi crearla applicando la seguente definizione dell’ingresso al tuo cluster. La definizione dell’ingresso riportata di seguito utilizza l’applicazione di esempio Istio Bookinfo descritta in [Implementazione dell’ingresso di Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy).
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
namespace: default
spec:
ingressClassName: cilium
rules:
- http:
paths:
- backend:
service:
name: details
port:
number: 9080
path: /details
pathType: Prefix
```
Puoi osservare la configurazione Cilium Envoy applicata con il seguente comando.
```
kubectl get cec -n kube-system cilium-ingress -o yaml
```
Puoi ottenere la porta del listener Envoy per il servizio `cilium-ingress` con il seguente comando. In questo esempio, la porta del listener condiviso è `8111`.
```
kubectl get cec -n kube-system cilium-ingress -o jsonpath={.spec.services[0].ports[0]}
```
1. Ottieni l’indirizzo IP dei nodi nel cluster.
```
kubectl get nodes -o wide
```
```
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
mi-026d6a261e355fba7 Ready 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. Accedi al servizio utilizzando gli indirizzi IP dei tuoi nodi e la `sharedListenerPort` per la risorsa`cilium-ingress`. Nell’esempio seguente l’indirizzo IP del nodo utilizzato è `10.80.146.32` e la porta del listener è `8111`. Sostituisci questi valori per il tuo ambiente.
```
curl -s http://10.80.146.32:8111/details/1 | jq
```
```
{
"id": 1,
"author": "William Shakespeare",
"year": 1595,
"type": "paperback",
"pages": 200,
"publisher": "PublisherA",
"language": "English",
"ISBN-10": "1234567890",
"ISBN-13": "123-1234567890"
}
```