View a markdown version of this page

Configurer Kubernetes Ingress pour les nœuds hybrides - Amazon EKS
AWS Application Load BalancerPrésentation de Cilium Ingress et Cilium GatewayComparaison entre Cilium Ingress et GatewayInstaller Cilium GatewayConfigurer la passerelle CiliumDéployer Cilium GatewayInstaller Cilium IngressConfigurer Cilium IngressDéployer Cilium IngressType de service LoadBalancerType de service NodePortRé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.

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 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 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.

Nœuds hybrides EKS Ingress

AWS Application Load Balancer

Vous pouvez utiliser le contrôleur d’équilibreur de charge AWS 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. 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

Conditions préalables

Procédure

  1. 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

  2. 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

  3. 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

  4. 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

  5. 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. Contrôleur de l'équilibreur de charge AWS

    • 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

  6. 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

  7. Créer un exemple d’application. L’exemple ci-dessous utilise l’application microservices Istio Bookinfo.

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

  8. 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

  9. Appliquez la configuration Ingress à votre cluster.

    kubectl apply -f my-ingress-alb.yaml

  10. 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 <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

  11. Accédez au service à l’aide de 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 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 de ressources Ingress existantes, il est AWS recommandé de commencer par l'API Gateway, car il s'agit d'un moyen plus expressif et plus 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, 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 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 Cilium Gateway, 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 des NodePort services par Cilium Gateway est prévue pour la version 1.18.x de Cilium (#27273)

2 Prise en charge de Cilium Gateway pour les équilibreurs de charge dédiés (#25567)

3 Support de Cilium Gateway pour TCP/UDP (#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'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. Pour plus d’informations, consultez Réseau hôte.

Conditions préalables

  1. Helm installé dans votre environnement de ligne de commande, consultez les Instructions de configuration de Helm.

  2. Cilium installé en suivant les instructions dans Configurer CNI pour les nœuds hybrides.

Procédure

  1. 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

  2. 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

  3. 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

  4. 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' 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 la passerelle, 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.kubernetes.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

Déployer Cilium Gateway

  1. Créer un exemple d’application. L’exemple ci-dessous utilise l’application microservices Istio Bookinfo.

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

  2. 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

  3. 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

  4. Appliquez la ressource Gateway à votre cluster.

    kubectl apply -f my-gateway.yaml

  5. Confirmez 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

  6. 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.

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. 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 é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.

  • 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 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"

Conditions préalables

  1. Helm installé dans votre environnement de ligne de commande, consultez les Instructions de configuration de Helm.

  2. Cilium installé en suivant les instructions dans Configurer CNI pour les nœuds hybrides.

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'é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

  2. 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

  3. 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 dans la documentation 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 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 et Exemples de types de chemins dans la documentation Cilium, ainsi que les exemples présentés dans cette section Déployer Cilium Ingress.

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.kubernetes.io/...
    service.kubernetes.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.

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

  2. 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

  3. 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

  4. Appliquez la ressource Ingress à votre cluster.

    kubectl apply -f my-ingress.yaml

  5. Confirmez 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 type de service partagé ou dédié LoadBalancer pour la ressource Ingress n'ait 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

  6. 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 existante de l’équilibreur de charge

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 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 et la documentation Kubernetes Gateway pour obtenir une liste des contrôleurs courants.

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).

Pas d’infrastructure d’équilibrage 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. L'IPAM de Cilium LB 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 n’est pas activée tant qu’une ressource CiliumLoadBalancerIPPool n’est pas créée.

Conditions préalables

Procédure

  1. 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 ressource CiliumLoadBalancerIPPool à 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"}]
  }
}'

    Ingress 

    kubectl patch ingress my-ingress --type=merge -p '{
  "metadata": {"annotations": {"lbipam.cilium.io/ips": "LB_IP_ADDRESS"}}
}'

  2. 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 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"

  3. Appliquez la ressource CiliumLoadBalancerIPPool à votre cluster.

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

  4. 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

  5. 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"

  6. Appliquez la ressource CiliumBGPAdvertisement à votre cluster.

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

  7. 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)

Conditions préalables

Procédure

  1. 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 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.

    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

  2. Vérifiez que le service pour la ressource Ingress a été mis à jour pour utiliser le type NodePort de service. 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 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

  3. 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

  4. 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 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 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.

Conditions préalables

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

  2. 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. 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 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]}

  3. 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

  4. 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 (#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 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

  2. 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.

    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]}

  3. 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

  4. 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"
}