AWS Application Load Balancer Présentation de Cilium Ingress et de Cilium Gateway Comparaison entre Cilium Ingress et Gateway Installez Cilium Gateway Configurer Cilium Gateway Déployez Cilium Gateway Installez Cilium Ingress Configurer Cilium Ingress Déployez Cilium Ingress Type de service LoadBalancer Type de service NodePort Réseau hôte

Aidez à améliorer cette page

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien Modifier cette page sur qui se trouve dans le volet droit de chaque page.

Configurer Kubernetes Ingress pour les nœuds hybrides

Cette rubrique décrit comment configurer Kubernetes Ingress pour les charges de travail exécutées sur les nœuds hybrides Amazon EKS. Kubernetes Ingress expose les routes HTTP et HTTPS provenant de l'extérieur du cluster aux services du cluster. Pour utiliser les ressources d'entrée, un contrôleur Kubernetes Ingress est nécessaire pour configurer l'infrastructure réseau et les composants qui desservent 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 est basée sur la source du trafic de l'application. Si le trafic d'applications provient d'une AWS région, il est AWS recommandé d'utiliser AWS ALB et le AWS Load Balancer Controller. Si le trafic applicatif provient de l'environnement local sur site ou périphérique, il est AWS recommandé d'utiliser les fonctionnalités d'entrée intégrées de Cilium, qui peuvent être utilisées avec ou sans infrastructure d'équilibreur de charge dans votre environnement.

AWS Application Load Balancer

Vous pouvez utiliser le AWS Load Balancer Controller et l'Application Load Balancer (ALB) avec le ip type de cible pour les charges de travail exécutées sur des nœuds hybrides. Lors de l'utilisation du type de cibleip, ALB transmet le trafic directement aux pods, en contournant le chemin réseau de la couche de service. Pour que l'ALB atteigne les cibles IP du pod sur les nœuds hybrides, le CIDR de votre pod local doit être routable sur votre réseau local. En outre, le AWS Load Balancer Controller utilise des webhooks et nécessite une communication directe depuis le plan de contrôle EKS. Pour de plus amples informations, veuillez consulter Configurer les webhooks pour les nœuds hybrides.

Considérations

Voir Acheminez le trafic d'applications et le trafic HTTP avec des équilibreurs de charge d'application et Installez le contrôleur AWS Load Balancer avec Helm pour plus d'informations sur AWS Application Load Balancer et Load Balancer AWS Controller.
Consultez Best Practices for Load Balancing pour savoir comment choisir entre AWS Application Load Balancer et AWS Network Load Balancer.
Voir les annotations d'entrée du AWS Load Balancer Controller pour la liste des annotations qui peuvent être configurées pour les ressources d'entrée avec Application Load Balancer. AWS

Prérequis

Cilium installé en suivant les instructions de. Configurer le CNI pour les nœuds hybrides
Le plan de contrôle BGP de Cilium est activé en suivant les instructions de. Configurer Cilium BGP pour les nœuds hybrides Si vous ne souhaitez pas utiliser BGP, vous devez utiliser une autre méthode pour rendre votre pod local CIDRs routable sur votre réseau local. Si vous ne rendez pas votre pod local CIDRs routable, ALB ne pourra pas enregistrer ou contacter les cibles IP de votre pod.
Helm est installé dans votre environnement de ligne de commande. Consultez les instructions de configuration de Helm pour plus d'informations.
eksctl installé dans votre environnement de ligne de commande, consultez les instructions d'installation d'eksctl pour plus d'informations.

Procédure

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


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

Créez une politique IAM à l'aide de la politique téléchargée à l'étape précédente.


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

Remplacez 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

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

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


kubectl get -n kube-system deployment aws-load-balancer-controller


NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   2/2     2            2           84s

Créez un exemple d'application. L'exemple ci-dessous utilise l'exemple d'application de microservices Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

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

Appliquez la configuration Ingress à votre cluster.
```
kubectl apply -f my-ingress-alb.yaml
```
Le provisionnement de l'ALB pour votre ressource Ingress peut prendre quelques minutes. Une fois l'ALB approvisionné, une adresse correspondant au nom DNS du déploiement de l'ALB sera attribuée à votre ressource Ingress. L'adresse aura le format<alb-name>-<random-string>.<region>.elb.amazonaws.com.
```
kubectl get ingress my-ingress
```
```
NAME         CLASS   HOSTS   ADDRESS                                                     PORTS   AGE
my-ingress   alb     *       my-ingress-alb-<random-string>.<region>.elb.amazonaws.com   80      23m
```

Accédez au Service en utilisant l'adresse de l'ALB.


curl -s http//my-ingress-alb-<random-string>.<region>.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 de Cilium Gateway

Les fonctionnalités d'entrée de Cilium sont intégrées à l'architecture de Cilium et peuvent être gérées à l'aide de l'API Kubernetes Ingress ou de l'API Gateway. Si vous ne disposez pas de ressources Ingress existantes, il est AWS recommandé de commencer par l'API Gateway, car il s'agit d'un moyen plus expressif et flexible de définir et de gérer les ressources réseau Kubernetes. L'API Kubernetes Gateway vise à normaliser la manière dont les ressources réseau pour Ingress, Load Balancing et Service Mesh sont définies et gérées dans les clusters Kubernetes.

Lorsque vous activez les fonctionnalités d'entrée ou de passerelle de Cilium, l'opérateur Cilium réconcilie les objets Ingress/Gateway du cluster et les proxys Envoy sur chaque nœud traitent le trafic réseau de couche 7 (L7). Cilium ne fournit pas directement d'infrastructures d'entrée/passerelle telles que les équilibreurs de charge. Si vous envisagez 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 d'entrée ou de passerelle, pour déployer et gérer l'infrastructure de l'équilibreur de charge.

Pour le trafic entrant/passerelle, Cilium gère le trafic réseau principal 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 responsable de l'application des règles de routage L7, des politiques et de la manipulation des demandes, de la gestion avancée du trafic, telle que le partage et la mise en miroir du trafic, ainsi que de la terminaison et de l'origine du TLS. Les proxys Envoy de Cilium sont déployés séparément DaemonSet (cilium-envoy) par défaut, ce qui permet à Envoy et à l'agent Cilium d'être mis à jour, dimensionnés et gérés séparément.

Pour plus d'informations sur le fonctionnement de Cilium Ingress et de Cilium Gateway, consultez les pages Cilium Ingress et Cilium Gateway dans la documentation de Cilium.

Comparaison entre Cilium Ingress et Gateway

Le tableau ci-dessous résume les fonctionnalités de Cilium Ingress et de Cilium Gateway à partir de la version 1.17.x de Cilium.

Fonctionnalité	Ingress	Passerelle
Type de service LoadBalancer	Oui	Oui
Type de service NodePort	Oui	N°¹
Réseau hôte	Oui	Oui
Équilibreur de charge partagé	Oui	Oui
Équilibreur de charge dédié	Oui	N° ²
Stratégies réseau	Oui	Oui
Protocoles	Couche 7 (HTTP (S), gRPC)	^{Couche 7 (HTTP (S), gRPC) 3}
Passthrough TLS	Oui	Oui
Gestion du trafic	Routage du chemin et de l'hôte	Routage du chemin et de l'hôte, redirection et réécriture d'URL, division du trafic, modification de l'en-tête

¹ La prise en charge des NodePort services par Cilium Gateway est prévue pour la version 1.18.x de Cilium (#27273)

² Support de Cilium Gateway pour les équilibreurs de charge dédiés (#25567)

³ Support de Cilium Gateway pour TCP/UDP (#21929)

Installez Cilium Gateway

Considérations

Cilium doit être configuré avec nodePort.enabled set to, true comme indiqué dans les exemples ci-dessous. Si vous utilisez la fonction de remplacement du proxy kube de Cilium, vous n'avez pas besoin de la configurer sur. nodePort.enabled true
Cilium doit être configuré avec envoy.enabled set to, 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'service.beta.kubernetes.io/aws-load-balancer-type: "external"annotation doit être définie sur la ressource Gateway afin d'empêcher l'ancien fournisseur de AWS cloud de créer un Classic Load Balancer for the Service du LoadBalancer type créé par Cilium pour la ressource Gateway.
Lorsque vous utilisez Cilium Gateway en mode réseau hôte, le mode Service de type est LoadBalancer désactivé. Le mode réseau hôte est utile pour les environnements qui ne disposent pas d'une infrastructure d'équilibrage de charge, voir Réseau hôte pour plus d'informations.

Prérequis

Helm est installé dans votre environnement de ligne de commande, voir les instructions de configuration de Helm.
Cilium a été installé en suivant les instructions fournies dans. Configurer le CNI pour les nœuds hybrides

Procédure

Installez les définitions de ressources personnalisées de l'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

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'équilibreur de charge par défaut et pour utiliser un mode distinct cilium-envoy DaemonSet pour les proxys Envoy configurés pour fonctionner 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

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

Vérifiez que l'opérateur Cilium, l'agent et les pods Envoy fonctionnent.


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 Gateway

Cilium Gateway est activé sur les objets Gateway en définissant la gatewayClassName valeur sur. cilium Le service créé par Cilium pour les ressources Gateway peut être configuré avec des champs sur l'objet Gateway. Les annotations courantes utilisées par les contrôleurs Gateway pour configurer l'infrastructure de l'équilibreur de charge peuvent être configurées à l'aide du champ de infrastructure l'objet Gateway. Lorsque vous utilisez l' LoadBalancer IPAM de Cilium (voir l'exemple ci-dessousType de service LoadBalancer), l'adresse IP à utiliser pour le type de service LoadBalancer peut être configurée dans le champ de l'objet Gateway. addresses Pour plus d'informations sur la configuration de Gateway, consultez la spécification de l'API Kubernetes 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: <LoadBalancer IP address>
  listeners:
  ...

Cilium et la spécification Kubernetes Gateway prennent en charge les ressources GatewayClass, Gateway, et HTTPRoute. GRPCRoute ReferenceGrant

Voir HTTPRouteles GRPCRoutespécifications pour la liste des champs disponibles.
Consultez les exemples de la Déployez Cilium Gateway section ci-dessous et ceux de la documentation de Cilium pour savoir comment utiliser et configurer ces ressources.

Déployez Cilium Gateway

Créez un exemple d'application. L'exemple ci-dessous utilise l'exemple d'application de microservices Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Vérifiez que l'application s'exécute 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

Créez un fichier nommé my-gateway.yaml avec les contenus suivants. L'exemple ci-dessous utilise l'service.beta.kubernetes.io/aws-load-balancer-type: "external"annotation pour empêcher l'ancien fournisseur de AWS cloud de créer un Classic Load Balancer for the Service du type LoadBalancer créé par Cilium 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

Appliquez la ressource Gateway à votre cluster.
```
kubectl apply -f my-gateway.yaml
```
Vérifiez que la ressource Gateway et le service correspondant ont été créés. À ce stade, il est prévu que le ADDRESS champ de la ressource de passerelle ne soit pas renseigné avec une adresse IP ou un nom d'hôte, et que le type LoadBalancer de service correspondant à la ressource de passerelle ne soit pas non plus associé à une adresse IP ou à un nom d'hôte.
```
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   <pending>     80:30912/TCP   24s
```
Passez Type de service LoadBalancer à pour configurer la ressource Gateway pour utiliser une adresse IP allouée par Cilium Load Balancer IPAM, Type de service NodePort et/ou pour configurer la ressource Gateway pour NodePort utiliser Réseau hôte ou héberger des adresses réseau.

Installez Cilium Ingress

Considérations

Cilium doit être configuré avec nodePort.enabled set to, true comme indiqué dans les exemples ci-dessous. Si vous utilisez la fonction de remplacement du proxy kube de Cilium, vous n'avez pas besoin de la configurer sur. nodePort.enabled true
Cilium doit être configuré avec envoy.enabled set to, true comme indiqué dans les exemples ci-dessous.
Avec ingressController.loadbalancerMode set todedicated, Cilium crée des services dédiés pour chaque ressource Ingress. Avec ingressController.loadbalancerMode set toshared, Cilium crée un type de service partagé LoadBalancer pour toutes les ressources d'entrée du cluster. Lorsque vous utilisez le mode d'équilibrage de shared charge, les paramètres du service partagé tels quelabels, annotationstype, et loadBalancerIP sont configurés dans la ingressController.service section des valeurs Helm. Consultez la référence des valeurs de Cilium Helm pour plus d'informations.
Lorsque ce paramètre est ingressController.default défini surtrue, Cilium est configuré comme contrôleur d'entrée par défaut pour le cluster et créera des entrées d'entrée même si elles ne ingressClassName sont pas spécifiées dans les ressources d'entrée.
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 NodePort modes Service de type LoadBalancer et Service de type sont désactivés. Pour plus d’informations, consultez Réseau hôte.
Définissez ingressController.service.annotations toujours les valeurs Helm pour empêcher l'ancien fournisseur de AWS cloud de créer un Classic Load Balancer pour le cilium-ingress service par défaut créé par le graphique Cilium Helm. service.beta.kubernetes.io/aws-load-balancer-type: "external"

Prérequis

Helm est installé dans votre environnement de ligne de commande, voir les instructions de configuration de Helm.
Cilium a été installé en suivant les instructions fournies dans. Configurer le CNI pour les nœuds hybrides

Procédure

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'équilibreur de charge par défaut et pour utiliser un dedicated mode distinct cilium-envoy DaemonSet pour les proxys Envoy configurés pour fonctionner 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

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

Vérifiez que l'opérateur Cilium, l'agent et les pods Envoy fonctionnent.


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 réglant le paramètre sur. ingressClassName cilium Le ou les services créés par Cilium pour les ressources Ingress peuvent être configurés avec des annotations sur les objets Ingress lors de l'utilisation du mode équilibreur de dedicated charge et dans la configuration Cilium/Helm lors de l'utilisation du mode équilibreur de charge. shared Ces annotations sont couramment utilisées par les contrôleurs d'entrée pour configurer l'infrastructure d'équilibrage de charge ou d'autres attributs du service tels que le type de service, le mode d'équilibrage de charge, les ports et le relais TLS. Les principales annotations sont décrites ci-dessous. Pour une liste complète des annotations prises en charge, consultez les annotations de Cilium Ingress dans la documentation de Cilium.

Annotation	Description
`ingress.cilium.io/loadbalancer-mode`	`dedicated`: type de service dédié LoadBalancer pour chaque ressource d'entrée (par défaut). `shared`: type de service unique LoadBalancer pour toutes les ressources d'entrée.
`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êchez les anciens fournisseurs de AWS cloud de fournir des services de type Classic Load Balancer for Services. LoadBalancer
`lbipam.cilium.io/ips`	Liste des adresses IP à allouer depuis Cilium IPAM LoadBalancer

Cilium et la spécification Kubernetes Ingress prennent en charge les règles de correspondance spécifiques à Exact, Prefix et Implémentation pour les chemins d'entrée. Cilium prend en charge le regex comme règle de correspondance spécifique à l'implémentation. Pour plus d'informations, consultez les exemples de types de chemins d'entrée et de priorité et de types de chemins dans la documentation de Cilium, ainsi que les exemples dans la Déployez Cilium Ingress section de cette page.

Un exemple d'objet Cilium Ingress est illustré 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éployez Cilium Ingress

Créez un exemple d'application. L'exemple ci-dessous utilise l'exemple d'application de microservices Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Vérifiez que l'application s'exécute 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

Créez un fichier nommé my-ingress.yaml avec les contenus suivants. L'exemple ci-dessous utilise l'service.beta.kubernetes.io/aws-load-balancer-type: "external"annotation pour empêcher l'ancien fournisseur de AWS cloud de créer un Classic Load Balancer for the Service du type LoadBalancer créé par Cilium 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

Appliquez la ressource Ingress à votre cluster.
```
kubectl apply -f my-ingress.yaml
```

Vérifiez que la ressource Ingress et le service correspondant ont été créés. À ce stade, il est prévu que le ADDRESS champ 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é du type LoadBalancer de 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   <pending>     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   <pending>     80:32088/TCP,443:30332/TCP   25s

Procédez Type de service LoadBalancer à la configuration de la ressource Ingress pour qu'elle utilise une adresse IP allouée par Cilium Load Balancer IPAM, et/ou Réseau hôte à configurer la ressource Ingress pour qu'elle utilise Type de service NodePort ou héberge des adresses réseau. NodePort

Type de service LoadBalancer

Infrastructure d'équilibreur de charge existante

Par défaut, pour Cilium Ingress et Cilium Gateway, Cilium crée un ou plusieurs services Kubernetes de type pour les ressources Ingress/Gateway. LoadBalancer 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 d'entrée ou de passerelle, l'adresse IP ou les noms d'hôte exposés en externe pour l'entrée ou la passerelle sont alloués à partir de l'infrastructure d'équilibrage de charge, qui est généralement fournie par un contrôleur d'entrée ou de passerelle.

De nombreux contrôleurs Ingress et Gateway utilisent des annotations pour détecter et configurer l'infrastructure de l'équilibreur de charge. Les annotations de ces contrôleurs d'entrée et de passerelle sont configurées sur les ressources d'entrée ou de passerelle, comme indiqué dans les exemples précédents ci-dessus. Consultez la documentation de votre contrôleur Ingress ou Gateway pour les annotations qu'il prend en charge et consultez la documentation de Kubernetes Ingress et celle de Kubernetes Gateway pour obtenir la liste des contrôleurs les plus populaires.

Important

Cilium Ingress and Gateway ne peuvent pas être utilisés avec le Load Balancer Controller et les AWS Network AWS Load Balancers () NLBs dotés de nœuds hybrides EKS. Si vous essayez de les utiliser ensemble, les cibles ne sont pas enregistrées, car le NLB tente de se connecter directement au Pod IPs qui soutient le type de service LoadBalancer lorsque le NLB target-type est défini sur ip (exigence pour utiliser le NLB avec des charges de travail exécutées sur des nœuds hybrides EKS).

Aucune infrastructure d'équilibreur de charge

Si vous ne disposez pas d'infrastructure d'équilibreur de charge ni de contrôleur Ingress/Gateway correspondant dans votre environnement, les ressources Ingress/Gateway et les types de services correspondants LoadBalancer peuvent être configurés pour utiliser les adresses IP allouées par la gestion des adresses IP Load Balancer (LB IPAM) de Cilium. Le Cilium LB IPAM peut être configuré avec des plages d'adresses IP connues issues de votre environnement sur site, et peut utiliser le support intégré du protocole BGP (Border Gateway Protocol) de Cilium ou les annonces L2 pour annoncer les adresses IP sur votre réseau local. LoadBalancer

L'exemple ci-dessous montre comment configurer le LB IPAM de Cilium avec une adresse IP à utiliser pour vos ressources d'entrée/passerelle, et comment configurer le plan de contrôle BGP de Cilium pour publier l'adresse IP sur le LoadBalancer réseau local. La fonctionnalité LB IPAM de Cilium est activée par défaut, mais elle ne l'est pas tant qu'une CiliumLoadBalancerIPPool ressource n'est pas créée.

Prérequis

Cilium Ingress ou Gateway installé en suivant les instructions figurant dans ou. Installez Cilium Ingress Installez Cilium Gateway
Ressources Cilium Ingress ou Gateway avec un exemple d'application déployé en suivant les instructions contenues dans ou. Déployez Cilium Ingress Déployez Cilium Gateway
Le plan de contrôle BGP de Cilium est activé en suivant les instructions de. Configurer Cilium BGP pour les nœuds hybrides Si vous ne souhaitez pas utiliser BGP, vous pouvez ignorer cette condition préalable, mais vous ne pourrez pas accéder à votre ressource Ingress ou Gateway tant que l'adresse LoadBalancer IP allouée par Cilium LB IPAM ne sera pas routable sur votre réseau local.

Procédure

Corrigez éventuellement la ressource Ingress ou Gateway pour demander une adresse IP spécifique à utiliser pour le type LoadBalancer de service. 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 CiliumLoadBalancerIPPool ressource à l'étape suivante. Dans les commandes ci-dessous, remplacez LB_IP_ADDRESS par l'adresse IP à laquelle demander le type de service LoadBalancer.

Passerelle
```
kubectl patch gateway -n default my-gateway --type=merge -p '{
  "spec": {
    "addresses": [{"type": "IPAddress", "value": "LB_IP_ADDRESS"}]
  }
}'
```
Entrée
```
kubectl patch ingress my-ingress --type=merge -p '{
  "metadata": {"annotations": {"lbipam.cilium.io/ips": "LB_IP_ADDRESS"}}
}'
```
Créez un fichier nommé cilium-lbip-pool-ingress.yaml avec une CiliumLoadBalancerIPPool ressource pour configurer la plage d'adresses IP Load Balancer pour vos ressources Ingress/Gateway.
- Si vous utilisez Cilium Ingress, Cilium applique automatiquement l'cilium.io/ingress: "true"étiquette aux services qu'il crée pour les ressources Ingress. Vous pouvez utiliser cette étiquette dans le serviceSelector champ de définition de la CiliumLoadBalancerIPPool ressource pour sélectionner les services éligibles à LB IPAM.
- Si vous utilisez Cilium Gateway, vous pouvez utiliser l'gateway.networking.k8s.io/gateway-nameétiquette dans les serviceSelector champs de définition des CiliumLoadBalancerIPPool ressources pour sélectionner les ressources Gateway éligibles à LB IPAM.
- Remplacez LB_IP_CIDR par la plage d'adresses IP à utiliser pour les adresses IP du Load Balancer. Pour sélectionner une adresse IP unique, utilisez un /32 CIDR. Pour plus d'informations, consultez la section Gestion des adresses LoadBalancer IP dans la documentation de Cilium.
```
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"
```
Appliquez la CiliumLoadBalancerIPPool ressource à votre cluster.
```
kubectl apply -f cilium-lbip-pool-ingress.yaml
```

Vérifiez qu'une adresse IP a été alloué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

Entrée


kubectl get ingress my-ingress


NAME         CLASS    HOSTS   ADDRESS        PORTS   AGE
my-ingress   cilium   *       LB_IP_ADDRESS   80      10m

Créez un fichier nommé cilium-bgp-advertisement-ingress.yaml avec une CiliumBGPAdvertisement ressource pour annoncer l'adresse LoadBalancer IP des ressources Ingress/Gateway. Si vous n'utilisez pas Cilium BGP, vous pouvez ignorer cette étape. L'adresse LoadBalancer IP utilisée pour votre ressource Ingress/Gateway doit être routable sur votre réseau local pour 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"

Appliquez la CiliumBGPAdvertisement ressource à votre cluster.
```
kubectl apply -f cilium-bgp-advertisement-ingress.yaml
```

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 possède pas d'infrastructure d'équilibreur de charge ni de contrôleur d'entrée correspondant, ou si vous gérez vous-même votre infrastructure d'équilibreur de charge ou si vous utilisez un équilibrage de charge basé sur le DNS, vous pouvez configurer Cilium Ingress pour créer des services de type pour les ressources d'entrée. NodePort Lors de l'utilisation NodePort avec Cilium Ingress, le type de service 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 du cluster sur le NodePort, il est ensuite transféré vers un module qui soutient le service, qui peut se trouver sur le même nœud ou sur un nœud différent.

Note

La prise en charge des NodePort services par Cilium Gateway est prévue pour la version 1.18.x de Cilium (#27273)

Prérequis

Cilium Ingress a été installé en suivant les instructions fournies dans. Installez Cilium Ingress
Ressources Cilium Ingress avec exemple d'application déployée en suivant les instructions de. Déployez Cilium Ingress

Procédure

Corrigez la ressource Ingress existante my-ingress pour la changer de type de service LoadBalancer en 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 d'entrée suivante à votre cluster. Notez que la définition d'entrée ci-dessous utilise l'exemple d'application Istio Bookinfo décrit dans. Déployez Cilium Ingress


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

Vérifiez que le service pour la ressource Ingress a été mis à jour pour utiliser le type NodePort de service. Notez le port du protocole HTTP dans la sortie. Dans l'exemple ci-dessous32353, il s'agit du port HTTP qui sera utilisé lors d'une étape ultérieure pour interroger le service. L'avantage d'utiliser Cilium Ingress avec un type de service 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 entrant, ce que vous ne pouvez pas faire pour un service de type standard sans 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   <none>        80:32353/TCP,443:30253/TCP   27m
```

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    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Accédez au type de service NodePort en utilisant les adresses IP de vos nœuds et celles NodePort capturées ci-dessus. Dans l'exemple ci-dessous, l'adresse IP du nœud utilisée est 10.80.146.32 et NodePort est32353. Remplacez-les par les valeurs de 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 type Service of NodePort, si vous ne disposez pas d'infrastructure d'équilibreur de charge ni de contrôleur d'entrée ou de passerelle, 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 d'entrée et de passerelle directement sur le réseau hôte. Lorsque le mode réseau hôte est activé pour une ressource d'entrée ou de passerelle, le type LoadBalancer et les NodePort modes de service sont automatiquement désactivés, le mode réseau hôte s'exclut mutuellement avec ces modes alternatifs pour chaque ressource d'entrée ou de passerelle. Comparé au mode Service de type, le NodePort mode réseau hôte offre une flexibilité supplémentaire quant à la gamme de ports pouvant être utilisés (il n'est pas limité à la NodePort plage 30000-32767) et vous pouvez configurer un sous-ensemble de nœuds sur lesquels les proxys Envoy s'exécutent sur le réseau hôte.

Prérequis

Cilium Ingress ou Gateway installé en suivant les instructions figurant dans ou. Installez Cilium Ingress Installez Cilium Gateway

Procédure

Passerelle

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

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 de passerelle suivante à votre cluster. La définition de passerelle ci-dessous utilise l'exemple d'application Istio Bookinfo décrit dans. Déployez Cilium Gateway Dans l'exemple ci-dessous, la ressource Gateway est configurée pour utiliser le 8111 port de l'écouteur HTTP, qui est le port de l'écouteur partagé pour les proxys Envoy exécutés sur le réseau hôte. Si vous utilisez un port privilégié (inférieur à 1023) pour la ressource Gateway, consultez la documentation de Cilium 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 de 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'écoute Envoy pour le cilium-gateway-my-gateway service à l'aide de la commande suivante. Dans cet exemple, le port d'écoute partagé est8111.
```
kubectl get cec cilium-gateway-my-gateway -o jsonpath={.spec.services[0].ports[0]}
```

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    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Accédez au service à l'aide des adresses IP de vos nœuds et du port d'écoute de la cilium-gateway-my-gateway ressource. Dans l'exemple ci-dessous, l'adresse IP du nœud utilisée est 10.80.146.32 et le port de l'écouteur est8111. Remplacez-les par les valeurs de 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 de Cilium en amont (#34028), Cilium Ingress en mode réseau hôte doit être utiliséloadbalancerMode: shared, ce qui crée un service unique de type ClusterIP pour toutes les ressources d'entrée du cluster. Si vous utilisez un port privilégié (inférieur à 1023) pour la ressource Ingress, consultez la documentation de Cilium pour obtenir des instructions.

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

Appliquez la configuration du réseau hôte Cilium Ingress à 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 d'entrée suivante à votre cluster. La définition d'entrée ci-dessous utilise l'exemple d'application Istio Bookinfo décrit dans. Déployez Cilium Ingress


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 de 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'écoute Envoy pour le cilium-ingress service à l'aide de la commande suivante. Dans cet exemple, le port d'écoute partagé est8111.


kubectl get cec -n kube-system cilium-ingress -o jsonpath={.spec.services[0].ports[0]}

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    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Accédez au service à l'aide des adresses IP de vos nœuds et sharedListenerPort de la cilium-ingress ressource. Dans l'exemple ci-dessous, l'adresse IP du nœud utilisée est 10.80.146.32 et le port de l'écouteur est8111. Remplacez-les par les valeurs de 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"
}
```

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

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

Conventions de rédaction

Configurer BGP

Configurer les LoadBalancer services