Annonce BGP des adresses IP externes pour les services de type LoadBalancer et les Ingresses à l'aide de NetScaler CPX

Dernière publication : Oct 02, 2026
Le support du service Kubernetes de type LoadBalancer est fourni par les équilibreurs de charge cloud dans un environnement cloud. Les fournisseurs de services cloud activent ce support en créant automatiquement un équilibreur de charge et en attribuant une adresse IP qui est affichée dans le cadre de l'état du service. Tout trafic destiné à l'adresse IP externe est équilibré en charge sur NodeIP et NodePort par l'équilibreur de charge cloud. Une fois que le trafic atteint le cluster Kubernetes, kube-proxy effectue le routage vers les pods d'application réels à l'aide de règles iptables ou de serveurs virtuels IP. Cependant, pour les environnements sur site, la configuration automatique de l'équilibreur de charge cloud n'est pas disponible.
Vous pouvez exposer les services de type LoadBalancer à l'aide du NetScaler Ingress Controller et des dispositifs NetScaler de niveau 1 tels que NetScaler VPX ou MPX. Le NetScaler VPX ou MPX résidant en dehors du cluster Kubernetes équilibre la charge du trafic entrant vers les services Kubernetes. Pour plus d'informations sur un tel déploiement, consultez Exposer les services de type LoadBalancer.
Cependant, il n'est pas toujours possible d'utiliser un dispositif ADC externe pour exposer le service de type LoadBalancer dans un environnement sur site. Parfois, il est souhaitable de gérer toutes les ressources associées à partir du cluster Kubernetes lui-même sans aucun composant externe. Le NetScaler Ingress Controller offre un moyen d'exposer le service de type LoadBalancer à l'aide de NetScaler CPX qui s'exécute au sein du cluster Kubernetes. Le tissu BGP existant pour acheminer le trafic vers les nœuds Kubernetes est utilisé pour implémenter cette solution.
Dans ce déploiement, NetScaler CPX est déployé en tant que daemonset sur les nœuds Kubernetes en mode hôte. NetScaler CPX établit une session de peering BGP avec vos routeurs réseau et utilise cette session de peering pour annoncer les adresses IP des services de cluster externes. Si vos routeurs ont une capacité ECMP, le trafic est équilibré en charge vers plusieurs instances CPX par le routeur en amont, qui à son tour équilibre la charge vers les pods d'application réels. Lorsque vous déployez le NetScaler CPX avec ce mode, NetScaler CPX ajoute des règles iptables pour chaque service de type LoadBalancer sur les nœuds Kubernetes. Le trafic destiné à l'adresse IP externe est acheminé vers les pods NetScaler CPX.
Le diagramme suivant explique un déploiement où NetScaler CPX expose un service de type LoadBalancer :
citrix-adc-cpx-service-type-lb
Comme le montre le diagramme, NetScaler CPX s'exécute en tant que daemon set et exécute une session BGP sur le port 179 sur l'adresse IP du nœud pointée par la ressource de nœud Kubernetes. Pour chaque service de type LoadBalancer ajouté au serveur API Kubernetes, le NetScaler Ingress Controller configure le NetScaler CPX pour annoncer l'adresse IP externe au routeur BGP configuré. Un préfixe /32 est utilisé pour annoncer les routes au routeur externe et l'adresse IP du nœud est utilisée comme passerelle pour atteindre l'adresse IP externe. Une fois que le trafic atteint le nœud Kubernetes, la règle iptables dirige le trafic vers NetScaler CPX qui à son tour équilibre la charge vers les pods de service réels.
Avec ce déploiement, vous pouvez également utiliser les ressources d'entrée Kubernetes et annoncer l'adresse IP virtuelle (VIP) d'entrée au routeur. Vous pouvez spécifier la variable d'environnement NS_VIP lors du déploiement du NetScaler Ingress Controller, qui agit comme la VIP pour toutes les ressources d'entrée. Lorsqu'une ressource Ingress est ajoutée, NetScaler CPX annonce la NS_VIP aux routeurs externes via BGP pour attirer le trafic. Une fois que le trafic arrive à la NS_VIP, NetScaler CPX effectue la commutation de contenu et l'équilibrage de charge comme spécifié dans la ressource d'entrée.
Remarque :
Pour que cette solution fonctionne, le NetScaler Ingress Controller doit s'exécuter en tant qu'utilisateur root et doit avoir la capacité NET_ADMIN.
Related information
Configurer

Déployer la solution NetScaler CPX pour les services de type LoadBalancer

Cette procédure explique comment déployer NetScaler CPX en tant que daemonset dans le réseau hôte pour exposer les services de type LoadBalancer.
Cette configuration comprend les tâches suivantes :
  • Déployer NetScaler CPX avec le NetScaler Ingress Controller en tant que sidecar
  • Configuration BGP
  • Configuration du service

Prérequis

  • Vous devez configurer le routeur en amont pour le routage BGP avec prise en charge ECMP et ajouter les nœuds Kubernetes en tant que voisins.
  • Si le routeur prend en charge l'équilibrage de charge, il est préférable d'utiliser un algorithme de hachage ECMP stable pour l'équilibrage de charge avec une entropie plus élevée pour un équilibrage de charge uniforme.
Effectuez les opérations suivantes :
  1. Téléchargez le fichier rbac.yaml et déployez les règles RBAC pour NetScaler CPX et le NetScaler Ingress Controller.
    kubectl apply -f rbac.yaml
  2. Téléchargez le citrix-k8s-cpx-ingress.yml à l'aide de la commande suivante.
    wget  https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/docs/configure/cpx-bgp-router/citrix-k8s-cpx-ingress.yml
  3. Modifiez le fichier citrix-k8s-cpx-ingress.yaml et spécifiez les valeurs requises.
    • L'argument –configmap spécifie l'emplacement de la ConfigMap pour le NetScaler Ingress Controller sous la forme de namespace/name.
    • L'argument --ipam citrix-ipam-controller peut être spécifié si vous exécutez le NetScaler IPAM Controller pour l'allocation automatique d'adresses IP.
    • (Facultatif) nodeSelector pour sélectionner les nœuds sur lesquels vous devez exécuter le daemonset NetScaler CPX. Par défaut, il est exécuté sur tous les nœuds de travail.
  4. Appliquez le fichier citrix-k8s-cpx-ingress.yaml pour créer un daemonset qui démarre NetScaler CPX et le NetScaler Ingress Controller.
    kubectl apply -f citrix-k8s-cpx-ingress.yml
  5. Créez une ConfigMap (configmap.yaml) avec la configuration BGP qui est transmise en tant qu'argument au NetScaler Ingress Controller. Pour des informations détaillées sur la configuration BGP, consultez Configuration BGP.
    Vous devez disposer des informations suivantes pour configurer le routage BGP :
    • L'adresse IP du routeur pour la connexion de NetScaler CPX
    • Le système autonome (numéro AS) du routeur
    • Le numéro AS pour NetScaler CPX
    Voici un exemple de ConfigMap avec la configuration BGP.
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: config
      labels:
        app: cic
    data:
      NS_BGP_CONFIG: |
        bgpConfig:
        - bgpRouter:
            localAS: 100
            neighbor:
            - address: 10.102.33.33
              remoteAS: 100
              advertisementInterval: 10
              ASOriginationInterval: 10
  6. Appliquez la ConfigMap créée à l'étape 5 pour appliquer la configuration BGP.
    kubectl apply -f configmap.yaml
  7. Créez un fichier YAML avec la configuration requise pour un service de type LoadBalancer.
    Remarque :
    Pour des informations détaillées, consultez configuration du service. La section de configuration du service explique les différentes manières d'obtenir une adresse IP externe pour le service et comment utiliser l'annotation de service fournie par NetScaler pour configurer différentes fonctionnalités de NetScaler.
    Voici un exemple de configuration de service de type LoadBalancer.
    apiVersion: v1
    kind: Service
    metadata:
      name: kuard-service
      annotations:
        # This uses IPAM to allocate an IP from range 'Dev'
        # service.citrix.com/ipam-range: 'Dev'
        service.citrix.com/frontend-ip: 172.217.163.17
        service.citrix.com/service-type-0: 'HTTP'
        service.citrix.com/service-type-1: 'SSL'
        service.citrix.com/lbvserver: '{"80-tcp":{"lbmethod":"ROUNDROBIN"}}'
        service.citrix.com/servicegroup: '{"80-tcp":{"usip":"yes"}}'
        service.citrix.com/ssl-termination: edge
        service.citrix.com/monitor: '{"80-tcp":{"type":"http"}}'
        service.citrix.com/frontend-httpprofile: '{"dropinvalreqs":"enabled", "websocket" : "enabled"}'
        service.citrix.com/backend-httpprofile: '{"dropinvalreqs":"enabled", "websocket" : "enabled"}'
        service.citrix.com/frontend-tcpprofile: '{"ws":"enabled", "sack" : "enabled"}'
        service.citrix.com/backend-tcpprofile: '{"ws":"enabled", "sack" : "enabled"}'
        service.citrix.com/frontend-sslprofile: '{"hsts":"enabled", "tls12" : "enabled"}'
        service.citrix.com/backend-sslprofile: '{"tls12" : "enabled"}
        service.citrix.com/ssl-certificate-data-1: |
          -----BEGIN-----
               [...]
          -----END-----
        service.citrix.com/ssl-key-data-1: |
    spec:
      type: LoadBalancer
      selector:
        app: kuard
      ports:
      - port: 80
        targetPort: 8080
        name: http
      - port: 443
        targetPort: 8443
        name: https
  8. Appliquez le service de type LoadBalancer.
    kubectl apply -f service-example.yaml
Une fois le service appliqué, le NetScaler Ingress Controller crée un serveur virtuel d'équilibrage de charge avec injection de santé de route BGP activée. Si l'état du serveur virtuel d'équilibrage de charge est UP, la route pour l'adresse IP externe est annoncée au routeur voisin avec un préfixe /32 et l'adresse IP du nœud comme passerelle.

Configuration BGP

La configuration BGP est effectuée à l'aide de la ConfigMap qui est transmise comme argument au NetScaler Ingress Controller.
Vous devez disposer des informations suivantes pour configurer le routage BGP :
  • L'adresse IP du routeur afin que NetScaler CPX puisse s'y connecter
  • Le système autonome (numéro AS) du routeur
  • Le numéro AS pour NetScaler CPX
Dans le ConfigMap suivant pour la configuration BGP, le champ bgpConfig représente la configuration BGP.

apiVersion: v1
kind: ConfigMap
metadata:
  name: config
  labels:
    app: cic
data:
  NS_BGP_CONFIG: |
    bgpConfig:
    - bgpRouter:
        localAS: 100
        neighbor:
        - address: x.x.x.x
          remoteAS: 100
          advertisementInterval: 10
          ASOriginationInterval: 10
Le tableau suivant explique les différents champs du champ bgpConfig.
Champ Description Type Valeur par défaut Obligatoire
nodeSelector Si le champ nodeSeclector est présent, la configuration du routeur BGP s'applique aux nœuds qui correspondent au champ nodeSelector. nodeSelector accepte des paires key=value séparées par des virgules où chaque clé représente un nom d'étiquette et la valeur est la valeur de l'étiquette. Par exemple : nodeSelector: datacenter=ds1,rack-rack1 chaîne Non
bgpRouter Spécifie la configuration BGP. Pour plus d'informations sur les différents champs de bgpRouter, consultez le tableau suivant. bgpRouter Oui
Le tableau suivant explique les champs du champ bgpRouter.
Champ Description Type Valeur par défaut Obligatoire
localAS Numéro AS pour le NetScaler CPX entier Oui
neighbor Configuration BGP du routeur voisin. voisin Oui
Le tableau suivant explique le champ neighbor.
Champ Description Type Valeur par défaut Obligatoire
address Adresse IP du routeur voisin. chaîne Oui
remoteAS Numéro AS du routeur voisin. entier Oui
advertisementInterval Ce champ définit un intervalle minimum entre l'envoi des mises à jour de routage BGP (en secondes). entier 10 secondes Oui
ASOriginationInterval Ce champ définit l'intervalle d'envoi des mises à jour de routage d'origine AS (en secondes). entier 10 secondes Oui

Voisins différents pour des nœuds différents

Par défaut, chaque nœud du cluster se connecte à tous les voisins listés dans la configuration. Cependant, si le cluster Kubernetes est réparti sur différents centres de données ou différents réseaux, des configurations de voisins différentes peuvent être nécessaires pour des nœuds différents. Vous pouvez utiliser le champ nodeSelector pour sélectionner les nœuds requis pour les configurations de routage BGP.
node-selector
Un exemple de ConfigMap avec la configuration nodeSelector est donné ci-dessous :

apiVersion: v1
kind: ConfigMap
metadata:
  name: config
  labels:
    app: cic
data:
  NS_BGP_CONFIG: |
    bgpConfig:
    - nodeSelector: datacenter=ds1
      bgpRouter:
        localAS: 100
        neighbor:
        - address: 10.102.33.44
          remoteAS: 100
          advertisementInterval: 10
          ASOriginationInterval: 10
    - nodeSelector: datacenter=ds2
      bgpRouter:
        localAS: 100
        neighbor:
        - address: 10.102.28.12
          remoteAS: 100
          advertisementInterval: 10
          ASOriginationInterval: 10
Dans cet exemple, le routeur avec l'adresse IP 10.102.33.44 est utilisé comme voisin par les nœuds avec l'étiquette datacenter=ds1. Le routeur avec l'adresse IP 10.102.28.12 est utilisé par les nœuds avec l'étiquette datacenter=ds2.

Configuration du service

Configuration de l'adresse IP externe

Une adresse IP externe pour le service de type LoadBalancer peut être obtenue en utilisant l'une des méthodes suivantes.
  • En spécifiant l'annotation service.citrix.com/frontend-ip dans la spécification du service comme suit.
    metadata:
        annotations:
            service.citrix.com/frontend-ip: 172.217.163.17
  • En spécifiant une adresse IP dans le champ spec.loadBalancerIP de la spécification du service comme suit.
    spec:
        loadBalancerIP: 172.217.163.17
  • En attribuant automatiquement une adresse IP virtuelle au service à l'aide du contrôleur IPAM fourni par NetScaler. Si l'une des deux autres méthodes est spécifiée, cette méthode a priorité sur le contrôleur IPAM. La solution IPAM est conçue de manière à ce que vous puissiez facilement l'intégrer avec des fournisseurs ExternalDNS tels qu'Infoblox. Pour plus d'informations, consultez Interopérabilité avec ExternalDNS. Pour le déploiement et l'utilisation du contrôleur IPAM NetScaler, consultez la documentation.

Configuration de l'annotation de service

Le contrôleur d'entrée NetScaler fournit de nombreuses annotations de service pour tirer parti des diverses fonctionnalités du NetScaler. Par exemple, le type de service par défaut pour le serveur virtuel d'équilibrage de charge est TCP, mais vous pouvez remplacer cette configuration par l'annotation service.citrix.com/service-type.
metadata:
    annotations:
        service.citrix.com/service-type-0: 'HTTP'
        service.citrix.com/service-type-1: 'SSL'
À l'aide des diverses annotations fournies par le contrôleur d'entrée NetScaler, vous pouvez tirer parti de diverses fonctionnalités ADC telles que le déchargement SSL, les politiques de réécriture et de réponse HTTP, et d'autres définitions de ressources personnalisées (CRD).
Pour plus d'informations sur toutes les annotations pour les services de type LoadBalancer, consultez annotations de service.
Pour l'utilisation des ressources secrètes pour les certificats SSL pour les services de type LoadBalancer, consultez Certificat SSL pour les services de type LoadBalancer.

Configuration de la politique de trafic externe

Par défaut, le contrôleur d'entrée NetScaler ajoute tous les pods de service en tant que back-end pour le service virtuel d'équilibrage de charge dans NetScaler CPX. Cette étape assure une meilleure haute disponibilité et une distribution égale aux instances de pods de service. Tous les nœuds exécutant NetScaler CPX annoncent les routes au serveur en amont et attirent le trafic du routeur. Ce comportement peut être modifié en définissant le spec.externalTrafficPolicy du service sur Local. Lorsque la politique de trafic externe est définie sur Local, seuls les pods exécutés sur le même nœud sont ajoutés en tant que back-end pour le serveur virtuel d'équilibrage de charge, comme illustré dans le diagramme suivant. Dans ce mode, seuls les nœuds qui ont les pods de service annoncent l'adresse IP externe au routeur et CPX envoie le trafic uniquement aux pods locaux. Si vous ne souhaitez pas que le trafic saute d'un nœud à l'autre pour des raisons de performance, vous pouvez utiliser cette fonctionnalité.

Utilisation des ressources Ingress

Le NetScaler Ingress Controller fournit une variable nt NS_VIP, qui est l'adresse IP externe pour toutes les ressources Ingress. Chaque fois qu'une ressource Ingress est ajoutée, NetScaler CPX annonce l'adresse IP Ingress aux routeurs externes. Le NetScaler Ingress Controller fournit diverses annotations pour Ingress. Pour plus d'informations, consultez la documentation sur les annotations Ingress.
Effectuez les étapes suivantes pour la configuration Ingress :
  1. Téléchargez le fichier rbac.yaml et déployez les règles RBAC pour NetScaler CPX et le NetScaler Ingress Controller.
    kubectl apply -f rbac.yaml
  2. Téléchargez le fichier citrix-k8s-cpx-ingress.yml à l'aide de la commande suivante.
    wget  https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/docs/configure/cpx-bgp-router/citrix-k8s-cpx-ingress.yml
  3. Modifiez le fichier citrix-k8s-cpx-ingress.yml et spécifiez les valeurs requises.
    • L'argument –configmap spécifie l'emplacement ConfigMap pour le NetScaler Ingress Controller sous la forme d'un espace de noms ou d'un nom.
    • La variable d'environnement NS_VIP pour spécifier l'adresse IP externe à utiliser pour toutes les ressources Ingress. (Ceci est un paramètre requis).
  4. Appliquez le fichier citrix-k8s-cpx-ingress.yml pour créer un daemonset qui démarre NetScaler CPX et le NetScaler Ingress Controller.
    kubectl apply -f citrix-k8s-cpx-ingress.yml
  5. Configurez BGP à l'aide de ConfigMap comme indiqué dans la section précédente.
  6. Déployez une ressource Ingress exemple comme suit. Cette étape annonce l'adresse IP spécifiée dans la variable d'environnement NS_VIP au routeur externe configuré dans ConfigMap.
    kubectl apply -f https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/docs/configure/cpx-bgp-router/ingress-example.yaml
  7. Accédez à l'application à l'aide de NS_VIP:<port>. Par défaut, Ingress utilise le port 80 pour la communication non sécurisée et le port 443 pour la communication sécurisée (si une section TLS est fournie).
Remarque : Actuellement, l'annotation ingress.citrix.com/frontend-ip n'est pas prise en charge pour les annonces BGP.

Installation de Helm

Vous pouvez utiliser les charts Helm pour installer le NetScaler CPX en tant que routeur BGP. Pour plus d'informations, consultez la documentation des charts Helm Citrix.

Dépannage

  • Par défaut, NetScaler CPX utilise la plage d'adresses IP 192.168.1.0/24 pour la communication interne, l'adresse IP 192.168.1.1 comme passerelle interne vers l'hôte, et l'adresse IP 192.168.1.2 comme NSIP. Les ports 9080 et 9443 sont utilisés comme ports de gestion entre le NetScaler Ingress Controller et NetScaler CPX pour HTTP et HTTPS. Si le réseau 192.168.1.0/24 se trouve dans la plage de PodCIDR, vous pouvez allouer un ensemble différent d'adresses IP pour la communication interne. Les variables d'environnement NS_IP et NS_GATEWAY contrôlent l'adresse IP utilisée par NetScaler CPX pour le NSIP et la passerelle respectivement. La même adresse IP doit également être spécifiée dans la variable d'environnement NS_IP du NetScaler Ingress Controller pour établir la communication entre le NetScaler Ingress Controller et NetScaler CPX.
  • Par défaut, BGP sur NetScaler CPX s'exécute sur le port 179 et tout le trafic BGP arrivant sur le port TCP 179 est géré par NetScaler CPX. S'il y a un conflit, par exemple si vous utilisez la capacité de peering BGP externe de Calico pour annoncer vos préfixes de cluster via BGP, vous pouvez modifier le port BGP avec la variable d'environnement du NetScaler Ingress Controller BGP_PORT.
  • Le mode USIP (Use Source IP) de NetScaler ne fonctionne pas en raison des contraintes de Kubernetes. Si l'adresse IP source est requise par le service, vous pouvez activer la fonction CIP (en-tête d'IP client) sur les services de type HTTP/SSL en utilisant les annotations suivantes.
    service.citrix.com/servicegroup: '{"cip":"ENABLED", “cipheader”:”x-forwarded-for”}'