**Aidez à améliorer cette page**
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Configurer Kubernetes Ingress pour les nœuds hybrides
Cette rubrique décrit comment configurer Kubernetes Ingress pour les charges de travail exécutées sur des nœuds hybrides Amazon EKS. [Kubernetes Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) expose les routes HTTP et HTTPS depuis l’extérieur du cluster vers les services au sein du cluster. Pour utiliser les ressources Ingress, un contrôleur Kubernetes Ingress est nécessaire pour configurer l’infrastructure réseau et les composants qui gèrent le trafic réseau.
AWS prend en charge AWS Application Load Balancer (ALB) et Cilium pour Kubernetes Ingress pour les charges de travail exécutées sur des nœuds hybrides EKS. La décision d’utiliser ALB ou Cilium pour Ingress dépend de la source du trafic applicatif. Si le trafic applicatif provient d’une région AWS, AWS recommande d’utiliser AWS ALB et l’AWS Load Balancer Controller. Si le trafic applicatif provient de l’environnement local sur site ou périphérique, AWS recommande d’utiliser les fonctionnalités Ingress intégrées à Cilium, qui peuvent être utilisées avec ou sans infrastructure d’équilibrage de charge dans votre environnement.
![\[Nœuds hybrides EKS Ingress\]](http://docs.aws.amazon.com/fr_fr/eks/latest/userguide/images/hybrid-nodes-ingress.png)
## AWS Application Load Balancer
Vous pouvez utiliser l’[AWS Load Balancer Controller](aws-load-balancer-controller.md) et l’Application Load Balancer (ALB) avec le type de cible `ip` pour les charges de travail s’exécutant sur des nœuds hybrides. Lorsque vous utilisez le type de cible `ip`, ALB transfère le trafic directement vers les pods, en contournant le chemin réseau de la couche Service. Pour qu’ALB atteigne les cibles IP des pods sur les nœuds hybrides, votre CIDR de pod sur site doit être routable sur votre réseau sur site. De plus, l’AWS Load Balancer Controller utilise des webhooks et nécessite une communication directe depuis le plan de contrôle EKS. Pour de plus amples informations, consultez [Configurer les webhooks pour les nœuds hybrides](hybrid-nodes-webhooks.md).
### Considérations
+ Voir [Routage du trafic des applications et du trafic HTTP avec des équilibreurs de charge Application Load Balancer](alb-ingress.md) et [Installez le contrôleur AWS Load Balancer avec Helm](lbc-helm.md) pour plus d’informations sur AWS Application Load Balancer et AWS Load Balancer Controller.
+ Consultez la section [Meilleures pratiques pour l’équilibrage de charge](https://docs.aws.amazon.com/eks/latest/best-practices/load-balacing.html) pour savoir comment choisir entre AWSApplication Load Balancer et AWS Network Load Balancer.
+ Consultez les annotations sur l’[AWS Load Balancer Controller Ingress](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/) pour obtenir la liste des annotations pouvant être configurées pour les ressources d’entrée avec AWS Application Load Balancer.
### Prérequis
+ Cilium installé en suivant les instructions dans [Configurer CNI pour les nœuds hybrides](hybrid-nodes-cni.md).
+ Le plan de contrôle Cilium BGP a été activé en suivant les instructions fournies dans [Configurer Cilium BGP pour les nœuds hybrides](hybrid-nodes-cilium-bgp.md). Si vous ne souhaitez pas utiliser BGP, vous devez utiliser une autre méthode pour rendre vos CIDR de pods sur site routables sur votre réseau sur site. Si vous ne rendez pas vos CIDR de pods sur site routables, ALB ne pourra pas enregistrer ni contacter vos cibles IP de pods.
+ Helm installé dans votre environnement de ligne de commande, consultez les instructions de configuration de Helm pour plus d’informations.[Déployez des applications avec Helm sur Amazon EKS](helm.md)
+ eksctl installé dans votre environnement de ligne de commande, consultez les [instructions d’installation d’eksctl](install-kubectl.md#eksctl-install-update) pour plus d’informations.
### Procédure
1. Téléchargez une politique IAM pour le contrôleur de l'équilibreur de charge AWS qui lui permet d'effectuer des appels aux API AWS en votre nom.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/refs/heads/main/docs/install/iam_policy.json
```
1. 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
```
1. Remplacez la valeur 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
```
1. Ajoutez le référentiel des Charts de Helm eks-charts et mettez à jour votre référentiel Helm local pour vous assurer que vous disposez des graphiques les plus récents.
```
helm repo add eks https://aws.github.io/eks-charts
```
```
helm repo update eks
```
1. Installez le contrôleur de l'équilibreur de charge AWS. Remplacez les valeurs correspondant au nom du cluster (`CLUSTER_NAME`), à la région AWS (`AWS_REGION`), à l’ID VPC `VPC_ID`() et à la version des Charts de Helm de l’AWS Load Balancer Controller (`AWS_LBC_HELM_VERSION`) par vos paramètres, puis exécutez la commande suivante. Si vous utilisez un cluster en mode mixte avec des nœuds hybrides et des nœuds dans le cloud AWS, vous pouvez exécuter l’AWS Load Balancer Controller sur les nœuds cloud en suivant les instructions disponibles à l’adresse [Contrôleur de l'équilibreur de charge AWS](hybrid-nodes-webhooks.md#hybrid-nodes-mixed-lbc).
+ Vous pouvez trouver la dernière version des Charts de Helm en exécutant `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. Vérifiez que l’AWS Load Balancer Controller a été installé correctement.
```
kubectl get -n kube-system deployment aws-load-balancer-controller
```
```
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 84s
```
1. Créer un exemple d’application. L’exemple ci-dessous utilise l’application microservices [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. Créez un fichier nommé `my-ingress-alb.yaml` avec les contenus suivants.
```
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. Appliquez la configuration Ingress à votre cluster.
```
kubectl apply -f my-ingress-alb.yaml
```
1. La configuration de l’ALB pour votre ressource Ingress peut prendre quelques minutes. Une fois l’ALB provisionné, votre ressource Ingress se verra attribuer une adresse correspondant au nom DNS du déploiement ALB. L’adresse aura le format `-..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. Accédez au service à l’aide de l’adresse de l’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"
}
```
## Présentation de Cilium Ingress et Cilium Gateway
Les fonctionnalités Ingress de Cilium sont intégrées à l’architecture de Cilium et peuvent être gérées à l’aide de l’API Ingress ou de l’API Gateway de Kubernetes. Si vous ne disposez pas encore de ressources Ingress, AWS recommandoe de commencer par l’API Gateway, car elle offre un moyen plus expressif et plus flexible de définir et de gérer les ressources réseau Kubernetes. [L’API Kubernetes Gateway](https://gateway-api.sigs.k8s.io/) vise à normaliser la manière dont les ressources réseau pour Ingress, l’équilibreur de charge et le maillage de services sont définies et gérées dans les clusters Kubernetes.
Lorsque vous activez les fonctionnalités Ingress ou Gateway de Cilium, l’opérateur Cilium synchronise les objets Ingress / Gateway dans le cluster et les proxys Envoy sur chaque nœud traitent le trafic réseau de couche 7 (L7). Cilium ne fournit pas directement d’infrastructure Ingress / Gateway telle que des équilibreurs de charge. Si vous prévoyez d’utiliser Cilium Ingress / Gateway avec un équilibreur de charge, vous devez utiliser les outils de l’équilibreur de charge, généralement un contrôleur Ingress ou Gateway, pour déployer et gérer l’infrastructure de l’équilibreur de charge.
Pour le trafic Ingress/Gateway, Cilium gère le trafic réseau central et l’application des politiques L3/L4, tandis que les proxys Envoy intégrés traitent le trafic réseau L7. Avec Cilium Ingress / Gateway, Envoy est chargé d’appliquer les règles de routage L7, les politiques et la manipulation des requêtes, la gestion avancée du trafic telle que la répartition et la mise en miroir du trafic, ainsi que la terminaison et l’origine TLS. Les proxys Envoy de Cilium sont déployés par défaut sous forme de DaemonSet (`cilium-envoy`) distinct, ce qui permet de mettre à jour, de dimensionner et de gérer séparément Envoy et l’agent Cilium.
Pour plus d’informations sur le fonctionnement de [Cilium Ingress](https://docs.cilium.io/en/stable/network/servicemesh/ingress/) et [Cilium Gateway](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/), consultez les pages Cilium Ingress et Cilium Gateway dans la documentation Cilium.
## Comparaison entre Cilium Ingress et Gateway
Le tableau ci-dessous résume les fonctionnalités de Cilium Ingress et Cilium Gateway dans la **version 1.17.x de Cilium**.
| Fonctionnalité | Ingress | Passerelle |
| --- | --- | --- |
| Type de service LoadBalancer | Oui | Oui |
| Type de service NodePort | Oui | N°1 |
| Réseau hôte | Oui | Oui |
| Équilibreur de charge partagé | Oui | Oui |
| Équilibreur de charge dédié | Oui | No2 |
| Stratégies réseau | Oui | Oui |
| Protocoles | Couche 7 (HTTP (S), gRPC) | Couche 7 (HTTP(S), gRPC)3 |
| TLS Passthrough | Oui | Oui |
| Gestion du trafic | Routage du chemin et d’hôte | Routage de chemin et d’hôte, redirection et réécriture d’URL, répartition du trafic, modification d’en-tête |
1 La prise en charge de Cilium Gateway pour les services NodePort est prévue pour la [version 1.18.x de Cilium (\$127273)](https://github.com/cilium/cilium/pull/27273)
2 Prise en charge de Cilium Gateway pour les équilibreurs de charge dédiés ([\$125567](https://github.com/cilium/cilium/issues/25567))
3 Prise en charge de Cilium Gateway pour TCP/UDP ([\$121929](https://github.com/cilium/cilium/issues/21929))
## Installer Cilium Gateway
### Considérations
+ Cilium doit être configuré avec `nodePort.enabled` réglé sur `true`, comme indiqué dans les exemples ci-dessous. Si vous utilisez la fonctionnalité de remplacement kube-proxy de Cilium, vous n’avez pas besoin de définir `nodePort.enabled` sur `true`.
+ Cilium doit être configuré avec `envoy.enabled` réglé sur `true`, comme indiqué dans les exemples ci-dessous.
+ Cilium Gateway peut être déployé en mode équilibreur de charge (par défaut) ou en mode réseau hôte.
+ Lorsque vous utilisez Cilium Gateway en mode équilibreur de charge, l’annotation `service.beta.kubernetes.io/aws-load-balancer-type: "external"` doit être définie sur la ressource Gateway afin d’empêcher le fournisseur de cloud hérité AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource Gateway.
+ Lorsque vous utilisez Cilium Gateway en mode réseau hôte, le service de type LoadBalancer est désactivé. Le mode réseau hôte est utile pour les environnements qui ne disposent pas d’une infrastructure d’équilibrage de charge. Pour plus d’informations, consultez [Réseau hôte](#hybrid-nodes-ingress-cilium-host-network).
### Prérequis
1. Helm installé dans votre environnement de ligne de commande, consultez les [Instructions de configuration de Helm](helm.md).
1. Cilium installé en suivant les instructions dans [Configurer CNI pour les nœuds hybrides](hybrid-nodes-cni.md).
### Procédure
1. Installez les définitions de ressources personnalisées (CRD) de l’API Kubernetes Gateway.
```
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. Créez un fichier nommé `cilium-gateway-values.yaml` avec le contenu suivant. L’exemple ci-dessous configure Cilium Gateway pour utiliser le mode d’équilibrage de charge par défaut et utiliser un DaemonSet `cilium-envoy` distinct pour les proxys Envoy configurés pour s’exécuter uniquement sur des nœuds hybrides.
```
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. Appliquez le fichier de valeurs Helm à votre 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. Vérifiez que l’opérateur Cilium, l’agent et les pods Envoy fonctionnent correctement.
```
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
```
## Configurer la passerelle Cilium
Cilium Gateway est activé sur les objets Gateway en définissant le paramètre `gatewayClassName` sur `cilium`. Le service créé par Cilium pour les ressources Gateway peut être configuré à l’aide des champs de l’objet Gateway. Les annotations couramment utilisées par les contrôleurs Gateway pour configurer l’infrastructure d’équilibrage de charge peuvent être configurées à l’aide du champ `infrastructure` de l’objet Gateway. Lorsque vous utilisez l’IPAM LoadBalancer de Cilium (voir exemple dans [Type de service LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer)), l’adresse IP à utiliser pour le service de type LoadBalancer peut être configurée dans le champ `addresses` de l’objet Gateway. Pour plus d’informations sur la configuration de la passerelle, consultez la [spécification de l’API Kubernetes Gateway](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.kuberentes.io/...
addresses:
- type: IPAddress
value:
listeners:
...
```
Cilium et la spécification Kubernetes Gateway prennent en charge les ressources GatewayClass, Gateway, HTTPRoute, GRPCRoute et ReferenceGrant.
+ Consultez les spécifications [HTTPRoute](https://gateway-api.sigs.k8s.io/api-types/httproute/HTTPRoute) et [GRPCRoute](https://gateway-api.sigs.k8s.io/api-types/grpcroute/GRPCRoute) pour obtenir la liste des champs disponibles.
+ Consultez les exemples dans la section [Déployer Cilium Gateway](#hybrid-nodes-ingress-cilium-gateway-deploy) ci-dessous et ceux dans la [documentation Cilium](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#examples) pour savoir comment utiliser et configurer ces ressources.
## Déployer Cilium Gateway
1. Créer un exemple d’application. L’exemple ci-dessous utilise l’application microservices [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. Vérifiez que l’application fonctionne correctement.
```
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. Créez un fichier nommé `my-gateway.yaml` avec les contenus suivants. L’exemple ci-dessous utilise l’annotation `service.beta.kubernetes.io/aws-load-balancer-type: "external"` pour empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource 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. Appliquez la ressource Gateway à votre cluster.
```
kubectl apply -f my-gateway.yaml
```
1. Confirmez que la ressource Gateway et le service correspondant ont été créés. À ce stade, il est prévu que le champ `ADDRESS` de la ressource Gateway ne soit pas renseigné avec une adresse IP ou un nom d’hôte, et que le service de type LoadBalancer pour la ressource Gateway ne dispose pas non plus d’adresse IP ou de nom d’hôte attribué.
```
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. Procédez à [Type de service LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer) pour configurer la ressource Gateway afin d’utiliser une adresse IP attribuée par Cilium Load Balancer IPAM, et [Type de service NodePort](#hybrid-nodes-ingress-cilium-nodeport) ou [Réseau hôte](#hybrid-nodes-ingress-cilium-host-network) pour configurer la ressource Gateway afin d’utiliser les adresses NodePort ou réseau hôte.
## Installer Cilium Ingress
### Considérations
+ Cilium doit être configuré avec `nodePort.enabled` réglé sur `true`, comme indiqué dans les exemples ci-dessous. Si vous utilisez la fonctionnalité de remplacement kube-proxy de Cilium, vous n’avez pas besoin de définir `nodePort.enabled` sur `true`.
+ Cilium doit être configuré avec `envoy.enabled` réglé sur `true`, comme indiqué dans les exemples ci-dessous.
+ Lorsque `ingressController.loadbalancerMode` est défini sur `dedicated`, Cilium crée des services dédiés pour chaque ressource Ingress. Lorsque `ingressController.loadbalancerMode` est défini sur `shared`, Cilium crée un service partagé de type LoadBalancer pour toutes les ressources Ingress du cluster. Lorsque vous utilisez le mode équilibreur de charge `shared`, les paramètres du service partagé tels que `labels`, `annotations`, `type` et `loadBalancerIP` sont configurés dans la section `ingressController.service` des valeurs Helm. Pour plus d’informations, consultez la [référence sur les valeurs Cilium Helm](https://github.com/cilium/cilium/blob/v1.17.6/install/kubernetes/cilium/values.yaml#L887).
+ Avec `ingressController.default` défini sur `true`, Cilium est configuré comme contrôleur Ingress par défaut pour le cluster et créera des entrées Ingress même lorsque `ingressClassName` n’est pas spécifié sur les ressources Ingress.
+ Cilium Ingress peut être déployé en mode équilibreur de charge (par défaut), port de nœud ou réseau hôte. Lorsque Cilium est installé en mode réseau hôte, les modes Service de type LoadBalancer et Service de type NodePort sont désactivés. Pour plus d’informations, consultez [Réseau hôte](#hybrid-nodes-ingress-cilium-host-network).
+ Définissez toujours `ingressController.service.annotations` sur `service.beta.kubernetes.io/aws-load-balancer-type: "external"` dans les valeurs Helm afin d’empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service par défaut `cilium-ingress` créé par les [Charts de Helm Cilium](https://github.com/cilium/cilium/blob/main/install/kubernetes/cilium/templates/cilium-ingress-service.yaml).
### Prérequis
1. Helm installé dans votre environnement de ligne de commande, consultez les [Instructions de configuration de Helm](helm.md).
1. Cilium installé en suivant les instructions dans [Configurer CNI pour les nœuds hybrides](hybrid-nodes-cni.md).
### Procédure
1. Créez un fichier nommé `cilium-ingress-values.yaml` avec le contenu suivant. L’exemple ci-dessous configure Cilium Ingress pour utiliser le mode d’équilibrage de charge `dedicated` par défaut et utiliser un DaemonSet distinct `cilium-envoy` pour les proxys Envoy configurés pour s’exécuter uniquement sur des nœuds hybrides.
```
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. Appliquez le fichier de valeurs Helm à votre 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. Vérifiez que l’opérateur Cilium, l’agent et les pods Envoy fonctionnent correctement.
```
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
```
## Configurer Cilium Ingress
Cilium Ingress est activé sur les objets Ingress en définissant le paramètre `ingressClassName` sur `cilium`. Les services créés par Cilium pour les ressources Ingress peuvent être configurés à l’aide d’annotations sur les objets Ingress lorsque vous utilisez le mode équilibreur de charge `dedicated`, et dans la configuration Cilium / Helm lorsque vous utilisez le mode équilibreur de charge `shared`. Ces annotations sont couramment utilisées par les contrôleurs Ingress pour configurer l’infrastructure de l’équilibreur de charge ou d’autres attributs du service, tels que le type de service, le mode de l’équilibreur de charge, les ports et le transfert TLS. Les annotations clés sont décrites ci-dessous. Pour obtenir la liste complète des annotations prises en charge, consultez les [annotations Cilium Ingress](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#supported-ingress-annotations) dans la documentation Cilium.
| Annotation | Description |
| --- | --- |
| `ingress.cilium.io/loadbalancer-mode` | `dedicated` : Service dédié de type LoadBalancer pour chaque ressource Ingress (par défaut). `shared` : Service unique de type LoadBalancer pour toutes les ressources Ingress. |
| `ingress.cilium.io/service-type` | `LoadBalancer` : le service sera de type LoadBalancer (par défaut) `NodePort` : Le service sera de type NodePort. |
| `service.beta.kubernetes.io/aws-load-balancer-type` | `"external"` : Empêcher les anciens fournisseurs de cloud AWS de provisionner un Classic Load Balancer pour les services de type LoadBalancer. |
| `lbipam.cilium.io/ips` | Liste des adresses IP à attribuer à partir de Cilium LoadBalancer IPAM |
Cilium et la spécification Kubernetes Ingress prennent en charge les règles de correspondance exacte, préfixe et spécifique à l’implémentation pour les chemins d’accès Ingress. Cilium prend en charge les expressions régulières comme règle de correspondance spécifique à son implémentation. Pour plus d’informations, consultez les sections [Types et priorité des chemins d’entrée](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#ingress-path-types-and-precedence) et [Exemples de types de chemins](https://docs.cilium.io/en/stable/network/servicemesh/path-types/) dans la documentation Cilium, ainsi que les exemples présentés dans cette section [Déployer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-deploy).
Un exemple d’objet Cilium Ingress est présenté ci-dessous.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
annotations:
service.beta.kuberentes.io/...
service.kuberentes.io/...
spec:
ingressClassName: cilium
rules:
...
```
## Déployer Cilium Ingress
1. Créer un exemple d’application. L’exemple ci-dessous utilise l’application microservices [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. Vérifiez que l’application fonctionne correctement.
```
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. Créez un fichier nommé `my-ingress.yaml` avec les contenus suivants. L’exemple ci-dessous utilise l’annotation `service.beta.kubernetes.io/aws-load-balancer-type: "external"` pour empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource 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. Appliquez la ressource Ingress à votre cluster.
```
kubectl apply -f my-ingress.yaml
```
1. Confirmez que la ressource Ingress et le service correspondant ont été créés. À ce stade, il est prévu que le champ `ADDRESS` de la ressource Ingress ne soit pas renseigné avec une adresse IP ou un nom d’hôte, et que le service partagé ou dédié de type LoadBalancer pour la ressource Ingress ne dispose pas non plus d’adresse IP ou de nom d’hôte attribué.
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress cilium * 80 8s
```
Pour le mode équilibreur de charge `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
```
Pour le mode équilibreur de charge `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. Procédez à [Type de service LoadBalancer](#hybrid-nodes-ingress-cilium-loadbalancer) pour configurer la ressource Ingress afin d’utiliser une adresse IP attribuée par Cilium Load Balancer IPAM, et [Type de service NodePort](#hybrid-nodes-ingress-cilium-nodeport) ou [Réseau hôte](#hybrid-nodes-ingress-cilium-host-network) pour configurer la ressource Ingress afin d’utiliser les adresses NodePort ou du réseau hôte.
## Type de service LoadBalancer
### Infrastructure existante de l’équilibreur de charge
Par défaut, pour Cilium Ingress et Cilium Gateway, Cilium crée des services Kubernetes de type LoadBalancer pour les ressources Ingress / Gateway. Les attributs du ou des services créés par Cilium peuvent être configurés via les ressources Ingress et Gateway. Lorsque vous créez des ressources Ingress ou Gateway, l’adresse IP ou les noms d’hôte exposés en externe pour Ingress ou Gateway sont attribués à partir de l’infrastructure d’équilibrage de charge, qui est généralement fournie par un contrôleur Ingress ou Gateway.
De nombreux contrôleurs Ingress et Gateway utilisent des annotations pour détecter et configurer l’infrastructure d’équilibrage de charge. Les annotations pour ces contrôleurs Ingress et Gateway sont configurées sur les ressources Ingress ou Gateway, comme indiqué dans les exemples précédents ci-dessus. Consultez la documentation de votre contrôleur Ingress ou Gateway pour connaître les annotations qu’il prend en charge et consultez la [documentation Kubernetes Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/) et la [documentation Kubernetes Gateway](https://gateway-api.sigs.k8s.io/implementations/) pour obtenir une liste des contrôleurs courants.
**Important**
Cilium Ingress et Gateway ne peuvent pas être utilisés avec l’AWS Load Balancer Controller et les Network Load Balancers (NLB) AWS avec les nœuds hybrides EKS. Tenter de les utiliser ensemble entraîne des cibles non enregistrées, car le NLB tente de se connecter directement aux adresses IP des pods qui prennent en charge le service de type LoadBalancer lorsque le NLB `target-type` est défini sur `ip` (condition requise pour utiliser NLB avec des charges de travail s’exécutant sur des nœuds hybrides EKS).
### Pas d’infrastructure d’équilibrage de charge
Si votre environnement ne dispose pas d’une infrastructure d’équilibrage de charge et du contrôleur Ingress / Gateway correspondant, les ressources Ingress / Gateway et les services de type LoadBalancer correspondants peuvent être configurés pour utiliser les adresses IP attribuées par la [gestion des adresses IP de l’équilibreur de charge](https://docs.cilium.io/en/stable/network/lb-ipam/) de Cilium (LB IPAM). L’IPAM du LB Cilium peut être configuré avec des plages d’adresses IP connues provenant de votre environnement sur site et peut utiliser la prise en charge intégrée du protocole de passerelle frontière (BGP) de Cilium ou les annonces L2 pour diffuser les adresses IP du LoadBalancer vers votre réseau sur site.
L’exemple ci-dessous montre comment configurer l’IPAM LB de Cilium avec une adresse IP à utiliser pour vos ressources Ingress / Gateway, et comment configurer le plan de contrôle BGP de Cilium pour annoncer l’adresse IP de l’équilibreur de charge au réseau sur site. La fonctionnalité LB IPAM de Cilium est activée par défaut, mais n’est pas activée tant qu’une ressource `CiliumLoadBalancerIPPool` n’est pas créée.
#### Prérequis
+ Cilium Ingress ou Gateway installé conformément aux instructions fournies dans [Installer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-install) ou [Installer Cilium Gateway](#hybrid-nodes-ingress-cilium-gateway-install).
+ Ressources Cilium Ingress ou Gateway avec exemple d’application déployée en suivant les instructions dans [Déployer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-deploy) ou [Déployer Cilium Gateway](#hybrid-nodes-ingress-cilium-gateway-deploy).
+ Le plan de contrôle Cilium BGP a été activé en suivant les instructions fournies dans [Configurer Cilium BGP pour les nœuds hybrides](hybrid-nodes-cilium-bgp.md). Si vous ne souhaitez pas utiliser BGP, vous pouvez ignorer cette condition préalable, mais vous ne pourrez pas accéder à votre ressource Ingress ou Gateway tant que l’adresse IP LoadBalancer attribuée par Cilium LB IPAM ne sera pas routable sur votre réseau sur site.
#### Procédure
1. Vous pouvez éventuellement modifier la ressource Ingress ou Gateway afin de demander une adresse IP spécifique à utiliser pour le service de type LoadBalancer. Si vous ne demandez pas d’adresse IP spécifique, Cilium attribuera une adresse IP à partir de la plage d’adresses IP configurée dans la ressource `CiliumLoadBalancerIPPool` à l’étape suivante. Dans les commandes ci-dessous, remplacez `LB_IP_ADDRESS` par l’adresse IP pour demander le service de type LoadBalancer.
**Passerelle**
```
kubectl patch gateway -n default my-gateway --type=merge -p '{
"spec": {
"addresses": [{"type": "IPAddress", "value": "LB_IP_ADDRESS"}]
}
}'
```
**Ingress**
```
kubectl patch ingress my-ingress --type=merge -p '{
"metadata": {"annotations": {"lbipam.cilium.io/ips": "LB_IP_ADDRESS"}}
}'
```
1. Créez un fichier nommé `cilium-lbip-pool-ingress.yaml` avec une ressource `CiliumLoadBalancerIPPool` pour configurer la plage d’adresses IP de l’équilibreur de charge pour vos ressources Ingress / Gateway.
+ Si vous utilisez Cilium Ingress, Cilium applique automatiquement le label `cilium.io/ingress: "true"` aux services qu’il crée pour les ressources Ingress. Vous pouvez utiliser cette étiquette dans le champ `serviceSelector` de la définition de la ressource `CiliumLoadBalancerIPPool` pour sélectionner les services éligibles à LB IPAM.
+ Si vous utilisez Cilium Gateway, vous pouvez utiliser l’étiquette `gateway.networking.k8s.io/gateway-name` dans les champs `serviceSelector` de la définition de ressource `CiliumLoadBalancerIPPool` pour sélectionner les ressources Gateway éligibles pour LB IPAM.
+ Remplacez `LB_IP_CIDR` par la plage d’adresses IP à utiliser pour les adresses IP de l’équilibreur de charge. Pour sélectionner une seule adresse IP, utilisez un CIDR `/32`. Pour plus d’informations, consultez la section [Gestion des adresses IP LoadBalancer](https://docs.cilium.io/en/stable/network/lb-ipam/) dans la documentation 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. Appliquez la ressource `CiliumLoadBalancerIPPool` à votre cluster.
```
kubectl apply -f cilium-lbip-pool-ingress.yaml
```
1. Confirmez qu’une adresse IP a été attribuée par Cilium LB IPAM pour la ressource Ingress / Gateway.
**Passerelle**
```
kubectl get gateway my-gateway
```
```
NAME CLASS ADDRESS PROGRAMMED AGE
my-gateway cilium LB_IP_ADDRESS True 6m41s
```
**Ingress**
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress cilium * LB_IP_ADDRESS 80 10m
```
1. Créez un fichier nommé `cilium-bgp-advertisement-ingress.yaml` avec une ressource `CiliumBGPAdvertisement` pour annoncer l’adresse IP du LoadBalancer pour les ressources Ingress / Gateway. Si vous n’utilisez pas Cilium BGP, vous pouvez ignorer cette étape. L’adresse IP du LoadBalancer utilisée pour votre ressource Ingress / Gateway doit être routable sur votre réseau local afin que vous puissiez interroger le service à l’étape suivante.
```
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. Appliquez la ressource `CiliumBGPAdvertisement` à votre cluster.
```
kubectl apply -f cilium-bgp-advertisement-ingress.yaml
```
1. Accédez au service à l’aide de l’adresse IP attribuée par 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"
}
```
## Type de service NodePort
Si votre environnement ne dispose pas d’une infrastructure d’équilibrage de charge et d’un contrôleur Ingress correspondant, ou si vous gérez vous-même votre infrastructure d’équilibrage de charge ou utilisez un équilibrage de charge basée sur DNS, vous pouvez configurer Cilium Ingress pour créer des services de type NodePort pour les ressources Ingress. Lorsque vous utilisez NodePort avec Cilium Ingress, le service de type NodePort est exposé sur un port de chaque nœud dans la plage de ports 30000-32767. Dans ce mode, lorsque le trafic atteint un nœud quelconque du cluster sur le NodePort, il est ensuite transféré vers un pod qui prend en charge le service, lequel peut se trouver sur le même nœud ou sur un nœud différent.
**Note**
La prise en charge de Cilium Gateway pour les services NodePort est prévue pour la version 1.18.x de Cilium ([\$127273](https://github.com/cilium/cilium/pull/27273))
### Prérequis
+ Cilium Ingress installé en suivant les instructions fournies dans [Installer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-install).
+ Ressources Cilium Ingress avec exemple d’application déployée en suivant les instructions dans [Déployer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-deploy).
### Procédure
1. Modifiez la ressource Ingress `my-ingress` existante pour la faire passer du type de service LoadBalancer à NodePort.
```
kubectl patch ingress my-ingress --type=merge -p '{
"metadata": {"annotations": {"ingress.cilium.io/service-type": "NodePort"}}
}'
```
Si vous n’avez pas créé la ressource Ingress, vous pouvez la créer en appliquant la définition Ingress suivante à votre cluster. Remarque : la définition d’Ingress ci-dessous utilise l’application exemple Istio Bookinfo décrite dans [Déployer Cilium Ingress](#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. Confirmez que le service pour la ressource Ingress a été mis à jour pour utiliser le type de service NodePort. Notez le port pour le protocole HTTP dans la sortie. Dans l’exemple ci-dessous, ce port HTTP est `32353`, qui sera utilisé dans une étape ultérieure pour interroger le service. L’avantage d’utiliser Cilium Ingress avec un service de type NodePort est que vous pouvez appliquer un routage basé sur le chemin et l’hôte, ainsi que des politiques réseau pour le trafic Ingress, ce qui n’est pas possible avec un service standard de type NodePort sans Ingress.
```
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. Obtenez les adresses IP des nœuds de votre 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. Accédez au service de type NodePort à l’aide des adresses IP de vos nœuds et du NodePort capturé ci-dessus. Dans l’exemple ci-dessous, l’adresse IP du nœud utilisée est `10.80.146.32` et le NodePort est `32353`. Remplacez-les par les valeurs correspondant à votre environnement.
```
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"
}
```
## Réseau hôte
Comme pour le service de type NodePort, si vous ne disposez pas d’une infrastructure d’équilibrage de charge et d’un contrôleur Ingress ou Gateway, ou si vous gérez vous-même votre équilibrage de charge à l’aide d’un équilibreur de charge externe, vous pouvez configurer Cilium Ingress et Cilium Gateway pour exposer les ressources Ingress et Gateway directement sur le réseau hôte. Lorsque le mode réseau hôte est activé pour une ressource Ingress ou Gateway, les modes Service de type LoadBalancer et NodePort sont automatiquement désactivés. Le mode réseau hôte est mutuellement exclusif avec ces modes alternatifs pour chaque ressource Ingress ou Gateway. Par rapport au service de type NodePort, le mode réseau hôte offre une flexibilité supplémentaire pour la plage de ports pouvant être utilisés (il n’est pas limité à la plage NodePort 30000-32767) et vous pouvez configurer un sous-ensemble de nœuds où les proxys Envoy s’exécutent sur le réseau hôte.
### Prérequis
+ Cilium Ingress ou Gateway installé conformément aux instructions fournies dans [Installer Cilium Ingress](#hybrid-nodes-ingress-cilium-ingress-install) ou [Installer Cilium Gateway](#hybrid-nodes-ingress-cilium-gateway-install).
### Procédure
#### Passerelle
1. Créez un fichier nommé `cilium-gateway-host-network.yaml` avec le contenu suivant.
```
gatewayAPI:
enabled: true
hostNetwork:
enabled: true
# uncomment to restrict nodes where Envoy proxies run on the host network
# nodes:
# matchLabels:
# role: gateway
```
1. Appliquez la configuration du réseau hôte Cilium Gateway à votre 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
```
Si vous n’avez pas créé la ressource Gateway, vous pouvez la créer en appliquant la définition Gateway suivante à votre cluster. La définition Gateway ci-dessous utilise l’application exemple Istio Bookinfo décrite dans [Déployer Cilium Gateway](#hybrid-nodes-ingress-cilium-gateway-deploy). Dans l’exemple ci-dessous, la ressource Gateway est configurée pour utiliser le port `8111` pour l’écouteur HTTP, qui est le port d’écouteur partagé pour les proxys Envoy s’exécutant sur le réseau hôte. Si vous utilisez un port privilégié (inférieur à 1023) pour la ressource Gateway, consultez la [documentation Cilium](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#bind-to-privileged-port) pour obtenir des instructions.
```
---
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
```
Vous pouvez observer la configuration Cilium Envoy appliquée à l’aide de la commande suivante.
```
kubectl get cec cilium-gateway-my-gateway -o yaml
```
Vous pouvez obtenir le port d’écouteur Envoy pour le service `cilium-gateway-my-gateway` à l’aide de la commande suivante. Dans cet exemple, le port d’écouteur partagé est `8111`.
```
kubectl get cec cilium-gateway-my-gateway -o jsonpath={.spec.services[0].ports[0]}
```
1. Obtenez les adresses IP des nœuds de votre 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. Accédez au service à l’aide des adresses IP de vos nœuds et du port d’écouteur de la ressource `cilium-gateway-my-gateway`. Dans l’exemple ci-dessous, l’adresse IP du nœud utilisée est `10.80.146.32` et le port d’écouteur est `8111`. Remplacez-les par les valeurs correspondant à votre environnement.
```
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"
}
```
#### Ingress
En raison d’un problème en amont avec Cilium ([\$134028](https://github.com/cilium/cilium/issues/34028)), Cilium Ingress en mode réseau hôte nécessite l’utilisation de `loadbalancerMode: shared`, qui crée un seul service de type ClusterIP pour toutes les ressources Ingress du cluster. Si vous utilisez un port privilégié (inférieur à 1023) pour la ressource Ingress, consultez la [documentation Cilium](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#bind-to-privileged-port) pour obtenir des instructions.
1. Créez un fichier nommé `cilium-ingress-host-network.yaml` avec le contenu suivant.
```
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. Appliquez la configuration Cilium Ingress du réseau hôte à votre 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
```
Si vous n’avez pas créé la ressource Ingress, vous pouvez la créer en appliquant la définition Ingress suivante à votre cluster. La définition d’Ingress ci-dessous utilise l’application exemple Istio Bookinfo décrite dans [Déployer Cilium Ingress](#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
```
Vous pouvez observer la configuration Cilium Envoy appliquée à l’aide de la commande suivante.
```
kubectl get cec -n kube-system cilium-ingress -o yaml
```
Vous pouvez obtenir le port d’écouteur Envoy pour le service `cilium-ingress` à l’aide de la commande suivante. Dans cet exemple, le port d’écouteur partagé est `8111`.
```
kubectl get cec -n kube-system cilium-ingress -o jsonpath={.spec.services[0].ports[0]}
```
1. Obtenez les adresses IP des nœuds de votre 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. Accédez au service à l’aide des adresses IP de vos nœuds et de `sharedListenerPort` pour la ressource `cilium-ingress`. Dans l’exemple ci-dessous, l’adresse IP du nœud utilisée est `10.80.146.32` et le port d’écouteur est `8111`. Remplacez-les par les valeurs correspondant à votre environnement.
```
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"
}
```