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 applicatif provient d’une région AWS, AWS recommande d’utiliser AWS ALB et l’AWS Load Balancer Controller. Si le trafic applicatif provient de l’environnement local sur site ou périphérique, AWS recommande d’utiliser les fonctionnalités Ingress intégrées à Cilium, qui peuvent être utilisées avec ou sans infrastructure d’équilibrage de charge dans votre environnement.

Nœuds hybrides EKS Ingress

AWS Application Load Balancer

Vous pouvez utiliser l’AWS Load Balancer Controller et l’Application Load Balancer (ALB) avec le type de cible ip pour les charges de travail s’exécutant sur des nœuds hybrides. Lorsque vous utilisez le type de cible ip, ALB transfère le trafic directement vers les pods, en contournant le chemin réseau de la couche Service. Pour qu’ALB atteigne les cibles IP des pods sur les nœuds hybrides, votre CIDR de pod sur site doit être routable sur votre réseau sur site. De plus, l’AWS Load Balancer Controller utilise des webhooks et nécessite une communication directe depuis le plan de contrôle EKS. Pour de plus amples informations, consultez Configurer les webhooks pour les nœuds hybrides.

Considérations

Prérequis

Procédure

  1. Téléchargez une politique IAM pour le contrôleur de l'équilibreur de charge AWS qui lui permet d'effectuer des appels aux API AWS en votre nom.

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

  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 contrôleur de l'équilibreur de charge AWS. Remplacez les valeurs correspondant au nom du cluster (CLUSTER_NAME), à la région AWS (AWS_REGION), à l’ID VPC VPC_ID() et à la version des Charts de Helm de l’AWS Load Balancer Controller (AWS_LBC_HELM_VERSION) par vos paramètres, puis exécutez la commande suivante. Si vous utilisez un cluster en mode mixte avec des nœuds hybrides et des nœuds dans le cloud AWS, vous pouvez exécuter l’AWS Load Balancer Controller sur les nœuds cloud en suivant les instructions disponibles à l’adresse Contrôleur de l'équilibreur de charge AWS.

    • 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 l’AWS Load Balancer Controller a été installé correctement.

    kubectl get -n kube-system deployment aws-load-balancer-controller
    NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   2/2     2            2           84s

  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 encore de ressources Ingress, AWS recommandoe de commencer par l’API Gateway, car elle offre un moyen plus expressif et plus flexible de définir et de gérer les ressources réseau Kubernetes. L’API Kubernetes Gateway vise à normaliser la manière dont les ressources réseau pour Ingress, l’équilibreur de charge et le maillage de services sont définies et gérées dans les clusters Kubernetes.

Lorsque vous activez les fonctionnalités Ingress ou Gateway de Cilium, l’opérateur Cilium synchronise les objets Ingress / Gateway dans le cluster et les proxys Envoy sur chaque nœud traitent le trafic réseau de couche 7 (L7). Cilium ne fournit pas directement d’infrastructure Ingress / Gateway telle que des équilibreurs de charge. Si vous prévoyez d’utiliser Cilium Ingress / Gateway avec un équilibreur de charge, vous devez utiliser les outils de l’équilibreur de charge, généralement un contrôleur Ingress ou Gateway, pour déployer et gérer l’infrastructure de l’équilibreur de charge.

Pour le trafic Ingress/Gateway, Cilium gère le trafic réseau central et l’application des politiques L3/L4, tandis que les proxys Envoy intégrés traitent le trafic réseau L7. Avec Cilium Ingress / Gateway, Envoy est chargé d’appliquer les règles de routage L7, les politiques et la manipulation des requêtes, la gestion avancée du trafic telle que la répartition et la mise en miroir du trafic, ainsi que la terminaison et l’origine TLS. Les proxys Envoy de Cilium sont déployés par défaut sous forme de DaemonSet (cilium-envoy) distinct, ce qui permet de mettre à jour, de dimensionner et de gérer séparément Envoy et l’agent Cilium.

Pour plus d’informations sur le fonctionnement de Cilium Ingress 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 de Cilium Gateway pour les services NodePort 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 Prise en charge 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’annotation service.beta.kubernetes.io/aws-load-balancer-type: "external" doit être définie sur la ressource Gateway afin d’empêcher le fournisseur de cloud hérité AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource Gateway.

  • Lorsque vous utilisez Cilium Gateway en mode réseau hôte, le service de type LoadBalancer est désactivé. Le mode réseau hôte est utile pour les environnements qui ne disposent pas d’une infrastructure d’équilibrage de charge. Pour plus d’informations, consultez Réseau hôte.

Prérequis

  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 (CRD) de l’API Kubernetes Gateway.

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gatewayclasses.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gateways.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_httproutes.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_referencegrants.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_grpcroutes.yaml

  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’équilibrage de charge par défaut et utiliser un DaemonSet cilium-envoy distinct pour les proxys Envoy configurés pour s’exécuter uniquement sur des nœuds hybrides.

    gatewayAPI:
  enabled: true
  # uncomment to use host network mode
  # hostNetwork:
  #   enabled: true
nodePort:
  enabled: true
envoy:
  enabled: true
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: eks.amazonaws.com/compute-type
            operator: In
            values:
            - hybrid

  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’IPAM LoadBalancer de Cilium (voir exemple dans Type de service LoadBalancer), l’adresse IP à utiliser pour le service de type LoadBalancer peut être configurée dans le champ addresses de l’objet Gateway. Pour plus d’informations sur la configuration de la passerelle, consultez la spécification de l’API Kubernetes Gateway.

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, HTTPRoute, GRPCRoute et 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’annotation service.beta.kubernetes.io/aws-load-balancer-type: "external" pour empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource Gateway.

    ---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: cilium
  infrastructure:
    annotations:
      service.beta.kubernetes.io/aws-load-balancer-type: "external"
  listeners:
  - protocol: HTTP
    port: 80
    name: web-gw
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-app-1
spec:
  parentRefs:
  - name: my-gateway
    namespace: default
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /details
    backendRefs:
    - name: details
      port: 9080

  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 champ ADDRESS de la ressource Gateway ne soit pas renseigné avec une adresse IP ou un nom d’hôte, et que le service de type LoadBalancer pour la ressource Gateway ne dispose pas non plus d’adresse IP ou de nom d’hôte attribué.

    kubectl get gateway my-gateway
    NAME         CLASS    ADDRESS   PROGRAMMED   AGE
my-gateway   cilium             True         10s
    kubectl get svc cilium-gateway-my-gateway
    NAME                        TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
cilium-gateway-my-gateway   LoadBalancer   172.16.227.247   <pending>     80:30912/TCP   24s

  6. Procédez à Type de service LoadBalancer pour configurer la ressource Gateway afin d’utiliser une adresse IP attribuée par Cilium Load Balancer IPAM, et Type de service NodePort ou Réseau hôte pour configurer la ressource Gateway afin d’utiliser les adresses NodePort ou réseau hôte.

Installer Cilium Ingress

Considérations

  • Cilium doit être configuré avec nodePort.enabled réglé sur true, comme indiqué dans les exemples ci-dessous. Si vous utilisez la fonctionnalité de remplacement kube-proxy de Cilium, vous n’avez pas besoin de définir nodePort.enabled sur true.

  • Cilium doit être configuré avec envoy.enabled réglé sur true, comme indiqué dans les exemples ci-dessous.

  • Lorsque ingressController.loadbalancerMode est défini sur dedicated, Cilium crée des services dédiés pour chaque ressource Ingress. Lorsque ingressController.loadbalancerMode est défini sur shared, Cilium crée un service partagé de type LoadBalancer pour toutes les ressources Ingress du cluster. Lorsque vous utilisez le mode équilibreur de charge shared, les paramètres du service partagé tels que labels, annotations, type et loadBalancerIP sont configurés dans la section ingressController.service des valeurs Helm. Pour plus d’informations, consultez la référence sur les valeurs Cilium Helm.

  • Avec ingressController.default défini sur true, Cilium est configuré comme contrôleur Ingress par défaut pour le cluster et créera des entrées Ingress même lorsque ingressClassName n’est pas spécifié sur les ressources Ingress.

  • Cilium Ingress peut être déployé en mode équilibreur de charge (par défaut), port de nœud ou réseau hôte. Lorsque Cilium est installé en mode réseau hôte, les modes Service de type LoadBalancer et Service de type NodePort sont désactivés. Pour plus d’informations, consultez Réseau hôte.

  • Définissez toujours ingressController.service.annotations sur service.beta.kubernetes.io/aws-load-balancer-type: "external" dans les valeurs Helm afin d’empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service par défaut cilium-ingress créé par les Charts de Helm Cilium.

Prérequis

  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’équilibrage de charge dedicated par défaut et utiliser un DaemonSet distinct cilium-envoy pour les proxys Envoy configurés pour s’exécuter uniquement sur des nœuds hybrides.

    ingressController:
  enabled: true
  loadbalancerMode: dedicated
  service:
    annotations:
      service.beta.kubernetes.io/aws-load-balancer-type: "external"
nodePort:
  enabled: true
envoy:
  enabled: true
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: eks.amazonaws.com/compute-type
            operator: In
            values:
            - hybrid

  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 : Service dédié de type LoadBalancer pour chaque ressource Ingress (par défaut).

shared : Service unique de type LoadBalancer pour toutes les ressources Ingress.

ingress.cilium.io/service-type

LoadBalancer : le service sera de type LoadBalancer (par défaut)

NodePort : Le service sera de type NodePort.

service.beta.kubernetes.io/aws-load-balancer-type

"external" : Empêcher les anciens fournisseurs de cloud AWS de provisionner un Classic Load Balancer pour les services de type LoadBalancer.

lbipam.cilium.io/ips

Liste des adresses IP à attribuer à partir de Cilium LoadBalancer IPAM

Cilium et la spécification Kubernetes Ingress prennent en charge les règles de correspondance exacte, préfixe et spécifique à l’implémentation pour les chemins d’accès Ingress. Cilium prend en charge les expressions régulières comme règle de correspondance spécifique à son implémentation. Pour plus d’informations, consultez les sections Types et priorité des chemins d’entrée 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.kuberentes.io/...
    service.kuberentes.io/...
spec:
  ingressClassName: cilium
  rules:
  ...

Déployer Cilium Ingress

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

    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’annotation service.beta.kubernetes.io/aws-load-balancer-type: "external" pour empêcher l’ancien fournisseur de cloud AWS de créer un Classic Load Balancer pour le service de type LoadBalancer que Cilium crée pour la ressource Ingress.

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "external"
spec:
  ingressClassName: cilium
  rules:
  - http:
      paths:
      - backend:
          service:
            name: details
            port:
              number: 9080
        path: /details
        pathType: Prefix

  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 champ ADDRESS de la ressource Ingress ne soit pas renseigné avec une adresse IP ou un nom d’hôte, et que le service partagé ou dédié de type LoadBalancer pour la ressource Ingress ne dispose pas non plus d’adresse IP ou de nom d’hôte attribué.

    kubectl get ingress my-ingress
    NAME         CLASS    HOSTS   ADDRESS   PORTS   AGE
my-ingress   cilium   *                 80      8s

    Pour le mode équilibreur de charge shared 

    kubectl -n kube-system get svc cilium-ingress
    NAME             TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
cilium-ingress   LoadBalancer   172.16.217.48   <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 pour configurer la ressource Ingress afin d’utiliser une adresse IP attribuée par Cilium Load Balancer IPAM, et Type de service NodePort ou Réseau hôte pour configurer la ressource Ingress afin d’utiliser les adresses NodePort ou du réseau hôte.

Type de service LoadBalancer

Infrastructure existante de l’équilibreur de charge

Par défaut, pour Cilium Ingress et Cilium Gateway, Cilium crée des services Kubernetes de type LoadBalancer pour les ressources Ingress / Gateway. Les attributs du ou des services créés par Cilium peuvent être configurés via les ressources Ingress et Gateway. Lorsque vous créez des ressources Ingress ou Gateway, l’adresse IP ou les noms d’hôte exposés en externe pour Ingress ou Gateway sont attribués à partir de l’infrastructure d’équilibrage de charge, qui est généralement fournie par un contrôleur Ingress ou Gateway.

De nombreux contrôleurs Ingress et Gateway utilisent des annotations pour détecter et configurer l’infrastructure d’équilibrage de charge. Les annotations pour ces contrôleurs Ingress et Gateway sont configurées sur les ressources Ingress ou Gateway, comme indiqué dans les exemples précédents ci-dessus. Consultez la documentation de votre contrôleur Ingress ou Gateway pour connaître les annotations qu’il prend en charge et consultez la documentation Kubernetes Ingress et la documentation Kubernetes Gateway pour obtenir une liste des contrôleurs courants.

Important

Cilium Ingress et Gateway ne peuvent pas être utilisés avec l’AWS Load Balancer Controller et les Network Load Balancers (NLB) AWS avec les nœuds hybrides EKS. Tenter de les utiliser ensemble entraîne des cibles non enregistrées, car le NLB tente de se connecter directement aux adresses IP des pods qui prennent en charge le service de type LoadBalancer lorsque le NLB target-type est défini sur ip (condition requise pour utiliser NLB avec des charges de travail s’exécutant sur des nœuds hybrides EKS).

Pas d’infrastructure d’équilibrage de charge

Si votre environnement ne dispose pas d’une infrastructure d’équilibrage de charge et du contrôleur Ingress / Gateway correspondant, les ressources Ingress / Gateway et les services de type LoadBalancer correspondants peuvent être configurés pour utiliser les adresses IP attribuées par la gestion des adresses IP de l’équilibreur de charge de Cilium (LB IPAM). L’IPAM du LB Cilium peut être configuré avec des plages d’adresses IP connues provenant de votre environnement sur site et peut utiliser la prise en charge intégrée du protocole de passerelle frontière (BGP) de Cilium ou les annonces L2 pour diffuser les adresses IP du LoadBalancer vers votre réseau sur site.

L’exemple ci-dessous montre comment configurer l’IPAM LB de Cilium avec une adresse IP à utiliser pour vos ressources Ingress / Gateway, et comment configurer le plan de contrôle BGP de Cilium pour annoncer l’adresse IP de l’équilibreur de charge au réseau sur site. La fonctionnalité LB IPAM de Cilium est activée par défaut, mais n’est pas activée tant qu’une ressource CiliumLoadBalancerIPPool n’est pas créée.

Prérequis

Procédure

  1. Vous pouvez éventuellement modifier la ressource Ingress ou Gateway afin de demander une adresse IP spécifique à utiliser pour le service de type LoadBalancer. Si vous ne demandez pas d’adresse IP spécifique, Cilium attribuera une adresse IP à partir de la plage d’adresses IP configurée dans la ressource CiliumLoadBalancerIPPool à l’étape suivante. Dans les commandes ci-dessous, remplacez LB_IP_ADDRESS par l’adresse IP pour demander le service de type LoadBalancer.

    Passerelle 

    kubectl patch gateway -n default my-gateway --type=merge -p '{
  "spec": {
    "addresses": [{"type": "IPAddress", "value": "LB_IP_ADDRESS"}]
  }
}'

    Ingress 

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

  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 IP LoadBalancer dans la documentation Cilium.

      apiVersion: cilium.io/v2alpha1
kind: CiliumLoadBalancerIPPool
metadata:
  name: bookinfo-pool
spec:
  blocks:
  - cidr: "LB_IP_CIDR"
  serviceSelector:
    # if using Cilium Gateway
    matchExpressions:
      - { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
    # if using Cilium Ingress
    matchLabels:
      cilium.io/ingress: "true"

  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 ressource CiliumBGPAdvertisement pour annoncer l’adresse IP du LoadBalancer pour les ressources Ingress / Gateway. Si vous n’utilisez pas Cilium BGP, vous pouvez ignorer cette étape. L’adresse IP du LoadBalancer utilisée pour votre ressource Ingress / Gateway doit être routable sur votre réseau local afin que vous puissiez interroger le service à l’étape suivante.

    apiVersion: cilium.io/v2alpha1
kind: CiliumBGPAdvertisement
metadata:
  name: bgp-advertisement-lb-ip
  labels:
    advertise: bgp
spec:
  advertisements:
    - advertisementType: "Service"
      service:
        addresses:
          - LoadBalancerIP
      selector:
        # if using Cilium Gateway
        matchExpressions:
          - { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
        # if using Cilium Ingress
        matchLabels:
          cilium.io/ingress: "true"

  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 dispose pas d’une infrastructure d’équilibrage de charge et d’un contrôleur Ingress correspondant, ou si vous gérez vous-même votre infrastructure d’équilibrage de charge ou utilisez un équilibrage de charge basée sur DNS, vous pouvez configurer Cilium Ingress pour créer des services de type NodePort pour les ressources Ingress. Lorsque vous utilisez NodePort avec Cilium Ingress, le service de type NodePort est exposé sur un port de chaque nœud dans la plage de ports 30000-32767. Dans ce mode, lorsque le trafic atteint un nœud quelconque du cluster sur le NodePort, il est ensuite transféré vers un pod qui prend en charge le service, lequel peut se trouver sur le même nœud ou sur un nœud différent.

Note

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

Prérequis

Procédure

  1. Modifiez la ressource Ingress my-ingress existante pour la faire passer du type de service LoadBalancer à NodePort.

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

    Si vous n’avez pas créé la ressource Ingress, vous pouvez la créer en appliquant la définition Ingress suivante à votre cluster. Remarque : la définition d’Ingress ci-dessous utilise l’application exemple Istio Bookinfo décrite dans Déployer Cilium Ingress.

    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. Confirmez que le service pour la ressource Ingress a été mis à jour pour utiliser le type de service NodePort. Notez le port pour le protocole HTTP dans la sortie. Dans l’exemple ci-dessous, ce port HTTP est 32353, qui sera utilisé dans une étape ultérieure pour interroger le service. L’avantage d’utiliser Cilium Ingress avec un service de type NodePort est que vous pouvez appliquer un routage basé sur le chemin et l’hôte, ainsi que des politiques réseau pour le trafic Ingress, ce qui n’est pas possible avec un service standard de type NodePort sans Ingress.

    kubectl -n default get svc cilium-ingress-my-ingress
    NAME                        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
cilium-ingress-my-ingress   NodePort   172.16.47.153   <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 service de type NodePort à l’aide des adresses IP de vos nœuds et du NodePort capturé ci-dessus. Dans l’exemple ci-dessous, l’adresse IP du nœud utilisée est 10.80.146.32 et le NodePort est 32353. Remplacez-les par les valeurs correspondant à votre environnement.

    curl -s http://10.80.146.32:32353/details/1 | jq
    {
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
}

Réseau hôte

Comme pour le service de type NodePort, si vous ne disposez pas d’une infrastructure d’équilibrage de charge et d’un contrôleur Ingress ou Gateway, ou si vous gérez vous-même votre équilibrage de charge à l’aide d’un équilibreur de charge externe, vous pouvez configurer Cilium Ingress et Cilium Gateway pour exposer les ressources Ingress et Gateway directement sur le réseau hôte. Lorsque le mode réseau hôte est activé pour une ressource Ingress ou Gateway, les modes Service de type LoadBalancer et NodePort sont automatiquement désactivés. Le mode réseau hôte est mutuellement exclusif avec ces modes alternatifs pour chaque ressource Ingress ou Gateway. Par rapport au service de type NodePort, le mode réseau hôte offre une flexibilité supplémentaire pour la plage de ports pouvant être utilisés (il n’est pas limité à la plage NodePort 30000-32767) et vous pouvez configurer un sous-ensemble de nœuds où les proxys Envoy s’exécutent sur le réseau hôte.

Prérequis

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