Contrôleur d'entrée Citrix ADC

Expose des services de type LoadBalancer

Vue d’ensemble des services de type LoadBalancer

Dans un environnement Kubernetes, un microservice est déployé sous la forme d’un ensemble d’espaces créés et détruits dynamiquement. Étant donné que l’ensemble des espaces qui font référence à un microservice change constamment, Kubernetes fournit une abstraction logique appelée service pour exposer votre microservice s’exécutant sur un ensemble d’espaces. Un service définit un ensemble logique d’espaces, ainsi que des stratégies pour y accéder.

Un service de type LoadBalancer est le moyen le plus simple d’exposer un microservice au sein d’un cluster Kubernetes au monde extérieur. Les services de type LoadBalancer sont pris en charge en mode natif dans les déploiements Kubernetes sur des clouds publics tels qu’AWS, GCP ou Azure. Dans les déploiements cloud, lorsque vous créez un service de type LoadBalancer, un équilibreur de charge géré dans le cloud est affecté au service. Le service est ensuite exposé à l’aide de l’équilibreur de charge.

Solution Citrix pour les services de type LoadBalancer

Il peut arriver que vous souhaitiez déployer votre cluster Kubernetes sur du bare metal ou sur site plutôt que de le déployer sur un cloud public. Lorsque vous exécutez vos applications sur des clusters Kubernetes bare metal, il est beaucoup plus facile d’acheminer le trafic TCP ou UDP à l’aide d’un service de type LoadBalancer qu’à l’aide d’Ingress. Même pour le trafic HTTP, c’est parfois plus pratique que l’entrée. Toutefois, aucune implémentation d’équilibrage de charge n’est disponible en mode natif pour les clusters Kubernetes bare metal. Citrix fournit un moyen d’équilibrer la charge de ces services à l’aide du Citrix ingress controller et de Citrix ADC.

Dans la solution Citrix pour les services de type LoadBalancer, le Citrix ingress controller déployé à l’intérieur du cluster Kubernetes configure un Citrix ADC déployé en dehors du cluster pour équilibrer la charge du trafic entrant. À l’aide de la solution Citrix, vous pouvez équilibrer la charge du trafic entrant vers le cluster Kubernetes, que le déploiement se fasse sur bare metal, sur site ou dans un cloud public. Étant donné que le Citrix ingress controller fournit une gestion flexible des adresses IP qui permet la mutualisation pour Citrix ADC, vous pouvez utiliser un seul Citrix ADC pour équilibrer la charge de plusieurs services ainsi que pour exécuter des fonctions d’entrée. Vous pouvez ainsi optimiser l’utilisation des ressources de l’équilibreur de charge et réduire considérablement vos dépenses opérationnelles.

Services de type LoadBalancer VS Kubernetes Ingress

Le tableau suivant résume une comparaison entre Kubernetes Ingress et les services de type LoadBalancer qui vous aide à choisir la bonne option en fonction de vos besoins :

Services de type LoadBalancer Entrée
Un moyen plus simple et plus rapide d’exposer un service. Il vous suffit de spécifier le type de service comme type=LoadBalancer dans la définition du service. Ingress fournit des fonctionnalités avancées, mais la mise en œuvre nécessite plus d’étapes. Vous devez écrire un objet Ingress en plus de la définition de service. En outre, les chances de commettre des erreurs lors de la définition de l’entrée sont plus grandes.
Nécessite une adresse IP distincte pour chaque service. Permet d’exposer plusieurs services à l’aide d’une seule adresse IP.
Transfère tous les types de trafic arrivant sur le port spécifié vers le service, qu’il s’agisse de HTTP, TCP ou UDP. Il n’existe aucun filtrage ni aucune option permettant d’effectuer un routage avancé. Riche en fonctionnalités et puissantes par rapport aux services de type LoadBalancer. Ingress fournit plusieurs options de routage. Par exemple, en utilisant l’entrée, vous pouvez effectuer un routage basé sur le chemin et le sous-domaine vers les services principaux.

Comment fonctionne la solution Citrix pour les services de type LoadBalancer sur des clusters bare metal

Par défaut, un service de type expose LoadBalancer simplement NodePorts pour le service dans un cluster Kubernetes bare metal. Il ne configure pas les équilibreurs de charge externes.

Citrix propose une solution de bout en bout pour les services de type LoadBalancer dans un cluster Kubernetes bare metal en fournissant à la fois la gestion IP et la configuration de l’équilibrage de charge externe. Avec la solution Citrix, lorsqu’un service de type LoadBalancer est créé dans le cluster bare metal, le Citrix ingress controller configure Citrix ADC en dehors du cluster Kubernetes (niveau 1) avec un serveur virtuel d’équilibrage de charge. Le serveur virtuel d’équilibrage de charge est configuré avec une adresse IP attribuée automatiquement par le contrôleur IPAM Citrix ou spécifiée manuellement dans la définition du service à l’aide du champ spec.loadBalancerIP. Une fois l’adresse IP configurée pour un service, vous pouvez utiliser l’adresse IP configurée pour accéder au service en externe.

Gestion des adresses IP à l’aide du contrôleur IPAM

Le contrôleur IPAM est un conteneur fourni par Citrix pour la gestion des adresses IP et il exécute en parallèle au Citrix ingress controller un espace dans le cluster Kubernetes. Pour les services de type LoadBalancer, vous pouvez utiliser le contrôleur IPAM pour allouer automatiquement des adresses IP à des services à partir d’une plage d’adresses IP spécifiée. Vous pouvez spécifier cette plage d’adresses IP dans le fichier YAML lors du déploiement du contrôleur IPAM à l’aide de YAML. Le Citrix ingress controller configure l’adresse IP allouée au service en tant qu’adresse IP virtuelle (VIP) dans Citrix ADC MPX ou VPX. À l’aide de cette adresse IP, vous pouvez accéder au service en externe.

Le contrôleur IPAM nécessite la CustomResourceDefinition (CRD) VIP fournie par Citrix. Le CRD VIP contient des champs pour le nom de service, l’espace de noms et l’adresse IP. Le CRD VIP est utilisé pour la communication interne entre le Citrix ingress controller et le contrôleur IPAM.

Le schéma suivant illustre le déploiement d’un équilibreur de charge de type de service dans lequel le contrôleur IPAM est utilisé pour attribuer une adresse IP à un service.

Services de type LoadBalancer

Lorsqu’un nouveau service de type Loadbalancer est créé, les événements suivants se produisent :

  1. Le Citrix ingress controller crée un objet CRD VIP pour le service chaque fois que le champ loadBalancerIP du service est vide.
  2. Le contrôleur IPAM attribue une adresse IP à l’objet CRD VIP.
  3. Une fois que l’objet CRD VIP est mis à jour avec l’adresse IP, le Citrix ingress controller configure automatiquement Citrix ADC.

Remarque :

Les définitions de ressources personnalisées (CRD) proposées par Citrix prennent également en charge les services de type LoadBalancer. Cela signifie que vous pouvez spécifier un service de type LoadBalancer en tant que nom de service lorsque vous créez un objet CRD et que vous appliquez le CRD au service.

La solution de contrôleur IPAM est conçue de telle sorte que vous pouvez facilement intégrer la solution à des fournisseurs DNS externes tels qu’ Infoblox. Pour plus d’informations sur ExternalDNS, consultez Interopérabilité avec ExternalDNS.

Expose les services de type LoadBalancer avec les adresses IP attribuées par le contrôleur IPAM

Cette rubrique fournit des informations sur la façon d’exposer des services de type LoadBalancer avec des adresses IP attribuées par le contrôleur IPAM.

Pour exposer un service de type équilibreur de charge avec une adresse IP provenant du contrôleur IPAM, effectuez les opérations suivantes :

  1. Déployer le CRD VIP
  2. Déployer le Citrix ingress controller
  3. Déployez le contrôleur IPAM.
  4. Déployez un exemple d’application.
  5. Créez un service de type LoadBalancer pour exposer l’application.
  6. Accédez au service.

Étape 1 : Déployer le CRD VIP

Effectuez l’étape suivante pour déployer le CRD VIP Citrix qui permet la communication entre le Citrix ingress controller et le contrôleur IPAM.

 kubectl create -f https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/crd/vip/vip.yaml

Pour plus d’informations sur les CRD VIP, reportez-vous à la section CustomResourceDefinition VIP.

Étape 2 : Déployer le Citrix ingress controller

Effectuez les étapes suivantes pour déployer le Citrix ingress controller avec l’argument contrôleur IPAM.

  1. Téléchargez citrix-k8s-ingress-controller.yaml à l’aide de la commande suivante :

    wget  https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/deployment/baremetal/citrix-k8s-ingress-controller.yaml
    
  2. Modifiez le fichier YAML du Citrix ingress controller :

    • Spécifiez les valeurs des variables d’environnement selon vos besoins. Pour plus d’informations sur la spécification des variables d’environnement, consultez la section Déployer le Citrix ingress controller.

    • Spécifiez le contrôleur IPAM en tant qu’argument à l’aide de ce qui suit :

         args:
         - --ipam
           citrix-ipam-controller
      

    Voici un extrait d’un exemple de fichier YAML du Citrix ingress controller avec l’argument du contrôleur IPAM :

    Remarque :

    Ce YAML est uniquement destiné à la démonstration et non à la version complète. Utilisez toujours la dernière version du YAML et modifiez selon vos besoins.

    apiVersion: v1
    kind: Pod
    metadata:
      name: cic-k8s-ingress-controller
      labels:
        app: cic-k8s-ingress-controller
    spec: 
      serviceAccountName: cic-k8s-role
      containers:
      - name: cic-k8s-ingress-controller
        image: "quay.io/citrix/citrix-k8s-ingress-controller:1.26.7"
        env:
        # Set Citrix ADC NSIP/SNIP, SNIP in case of HA (mgmt has to be enabled) 
          - name: "NS_IP"
            value: "x.x.x.x"
            # Set the username
          - name: "NS_USER"
            valueFrom:
              secretKeyRef:
                name: nslogin
                key: username
            # Set user password
          - name: "NS_PASSWORD"
            valueFrom:
              secretKeyRef:
                name: nslogin
                key: password
            # Set log level
          - name: "EULA"
            value: "yes"
        args:
          - --ingress-classes
            citrix
          - --feature-node-watch
            false
          - --ipam
            citrix-ipam-controller
        imagePullPolicy: Always
    
  3. Déployez le Citrix ingress controller à l’aide du fichier YAML modifié à l’aide de la commande suivante :

    kubectl create -f citrix-k8s-ingress-controller.yaml
    

    Pour plus d’informations sur la façon de déployer le Citrix ingress controller, consultez la section Déployer le Citrix ingress controller.

Étape 3 : Déployer le contrôleur IPAM

Effectuez les étapes suivantes pour déployer le contrôleur IPAM.

  1. Téléchargez le fichier citrix-ipam-controller.yaml .

    Le manifeste contient deux variables d’environnement, VIP_RANGE et VIP_NAMESPACES. Vous pouvez spécifier la plage d’adresses IP routables appropriée avec un CIDR valide sous le VIP_RANGE. Si nécessaire, vous pouvez également spécifier un ensemble d’espaces de noms sous VIP_NAMESPACES afin que le contrôleur IPAM alloue des adresses uniquement pour les services provenant d’espaces de noms spécifiques.

    Pour plus d’informations, consultez VIP_RANGE et VIP_NAMESPACES.

  2. Déployez le contrôleur IPAM à l’aide de la commande suivante :

    kubectl create -f citrix-ipam-controller.yaml
    

Étape 4 : Déployer un exemple d’application

Effectuez les opérations suivantes pour déployer une apache application dans votre cluster Kubernetes.

Remarque :

Dans cet exemple, une apache application est utilisée. Vous pouvez déployer un exemple d’application de votre choix.

  1. Créez un fichier nommé apache-deployment.yaml avec la configuration suivante :

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: apache
      labels:
       name: apache
    spec:
      selector:
        matchLabels:
          app: apache
      replicas: 8
      template:
        metadata:
          labels:
            app: apache
        spec:
          containers:
          - name: apache
            image: httpd:latest
            ports:
            - name: http
              containerPort: 80
            imagePullPolicy: IfNotPresent
    
  2. Déployez l’application apache à l’aide de la commande suivante :

    kubectl create -f apache-deployment.yaml
    
  3. Vérifiez si les espaces sont en cours d’exécution à l’aide des éléments suivants :

    kubectl get pods
    

    Sortie :

    NAME                      READY   STATUS   RESTARTS   AGE
    apache-7db8f797c7-2x6jc   1/1     Running   0          8s
    apache-7db8f797c7-cdgmw   1/1     Running   0          8s
    apache-7db8f797c7-lh447   1/1     Running   0          8s
    apache-7db8f797c7-m7mhd   1/1     Running   0          8s
    apache-7db8f797c7-m9rn7   1/1     Running   0          8s
    apache-7db8f797c7-r9jgz   1/1     Running   0          8s
    apache-7db8f797c7-vwhc8   1/1     Running   0          8s
    apache-7db8f797c7-zslwv   1/1     Running   0          8s
    

Étape 5 : Exposer l’exemple d’application à l’aide d’un service de type LoadBalancer

Effectuez les opérations suivantes pour créer un service (apache) de type LoadBalancer.

  1. Créez un fichier nommé apache-service.yaml avec la configuration suivante :

    apiVersion: v1
    kind: Service
    metadata:
      name: apache
      labels:
        name: apache
    spec:
      externalTrafficPolicy: Local
      type: LoadBalancer
      ports:
      - name: http
        port: 80
        targetPort: http
      selector:
        app: apache
    
  2. Déployez le service à l’aide de la commande suivante :

    kubectl create -f apache-service.yaml
    

    Lorsque vous créez le service, le contrôleur IPAM attribue une adresse IP au apache service à partir de la plage d’adresses IP que vous avez définie lors du déploiement du contrôleur IPAM. L’adresse IP allouée par le contrôleur IPAM est fournie dans le champ status.loadBalancer.ingress: de la définition du service. Le Citrix ingress controller configure l’adresse IP allouée au service en tant qu’adresse IP virtuelle (VIP) dans Citrix ADC.

  3. Affichez le service à l’aide de la commande suivante :

    kubectl get service apache --output yaml
    

    Sortie :

    Sortie LoadBalancer du type de service

Étape 6 : accéder au service

Vous pouvez accéder au apache service à l’aide de l’adresse IP attribuée par le contrôleur IPAM au service. Vous pouvez trouver l’adresse IP dans le champ status.loadBalancer.ingress: de la définition du service. Utilisez la commande curl pour accéder au service :

curl <IP_address>

La réponse doit être :

<html><body><h1>It works!</h1></body></html>

Exposer les services de type LoadBalancer en spécifiant une adresse IP

Vous pouvez également exposer un service de type LoadBalancer manuellement en spécifiant une adresse IP dans votre définition de service.

Pour exposer un service de type LoadBalancer manuellement, vous pouvez spécifier l’adresse IP dans le fichier YAML de définition de service comme suit.

spec:
  type: LoadBalancer
  loadBalancerIP: "<ip-address>"

Lorsque vous créez un service de type LoadBalancer, le Citrix ingress controller configure l’adresse IP que vous avez définie dans le champ spec.loadBalancerIP en tant qu’adresse IP virtuelle (VIP) dans Citrix ADC.

Exemple : Exposer une application Apache à l’aide d’un service de type LoadBalancer en spécifiant une adresse IP

Procédez comme suit :

  1. Créez un fichier nommé apache-deployment.yaml avec la configuration suivante :

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: apache
      labels:
        name: apache
    spec:
      selector:
        matchLabels:
          app: apache
      replicas: 8
      template:
        metadata:
          labels:
            app: apache
        spec:
          containers:
          - name: apache
            image: httpd:latest
            ports:
            - name: http
              containerPort: 80
            imagePullPolicy: IfNotPresent
    
  2. Déployez l’application apache à l’aide de la commande suivante :

    kubectl create -f apache-deployment.yaml
    
  3. Vérifiez si les espaces sont en cours d’exécution à l’aide des éléments suivants :

    kubectl get pods
    

    Sortie :

    NAME                      READY   STATUS   RESTARTS   AGE
    apache-7db8f797c7-2x6jc   1/1     Running   0          8s
    apache-7db8f797c7-cdgmw   1/1     Running   0          8s
    apache-7db8f797c7-lh447   1/1     Running   0          8s
    apache-7db8f797c7-m7mhd   1/1     Running   0          8s
    apache-7db8f797c7-m9rn7   1/1     Running   0          8s
    apache-7db8f797c7-r9jgz   1/1     Running   0          8s
    apache-7db8f797c7-vwhc8   1/1     Running   0          8s
    apache-7db8f797c7-zslwv   1/1     Running   0          8s
    
  4. Créez un service (apache) de type LoadBalancer. Créez un nom de fichier apache-service.yaml avec la configuration suivante :

    apiVersion: v1
    kind: Service
    metadata:
      name: apache
      labels:
        name: apache
    spec:
      externalTrafficPolicy: Local
      loadBalancerIP: "10.217.212.16"
      type: LoadBalancer
      ports:
        - name: http
          port: 80
          targetPort: http
      selector:
        app: apache
    
  5. Déployez le service à l’aide de la commande suivante :

    kubectl create -f apache-service.yaml
    

    Lorsque vous créez le service (apache), le Citrix ingress controller est configuré 192.217.212.16 en tant qu’adresse IP virtuelle (VIP) dans Citrix ADC VPX.

  6. Accédez au apache service à l’aide de l’adresse IP (192.217.212.16) que vous lui avez attribuée. Utilisez la commande curl pour accéder au service :

    curl 192.217.212.16
    

    La réponse doit être :

    <html><body><h1>It works!</h1></body></html>
    

Exemple de cas d’utilisation : Exposer des microservices à l’aide de services de type LoadBalancer dans un déploiement à deux niveaux Citrix ADC

Cet exemple montre comment exposer des microservices déployés dans Kubernetes à des clients extérieurs au cluster à l’aide de services de type LoadBalancer dans un déploiement à deux niveaux Citrix ADC.

Vous pouvez déployer Citrix ADC VPX, MPX ou CPX en tant qu’équilibreur de charge au niveau 1 pour gérer le trafic nord-sud à grande échelle vers les microservices. Au niveau 2, vous pouvez déployer Citrix ADC CPX en tant que routeur de microservices L7 intelligent pour le trafic Nord-Sud et Est-Ouest. Dans cet exemple, un Citrix ADC VPX (service de type LoadBalancer) est utilisé au niveau 1 et un Citrix ADC CPX (entrée) est utilisé au niveau 2.

Le schéma suivant illustre le déploiement de microservices dans cet exemple. Le déploiement contient trois services qui sont mis en surbrillance respectivement en bleu, rouge et vert. Le déploiement contient 12 espaces s’exécutant sur deux nœuds de travail. Ces déploiements sont logiquement classés à l’aide d’espaces de noms Kubernetes.

Exemple de déploiement de microservices

Conditions préalables

Assurez-vous que vous avez :

Déployer des microservices à l’aide du service Kubernetes de type solution LoadBalancer

  1. Clonez le référentiel GitHub sur votre nœud maître à l’aide de la commande suivante :

    git clone https://github.com/citrix/example-cpx-vpx-for-kubernetes-2-tier-microservices.git
    
  2. À l’aide de la console CLI du nœud maître, créez des espaces de noms à l’aide de la commande suivante :

    kubectl create -f namespace.yaml
    

    Vérifiez si les espaces de noms sont créés dans votre cluster Kubernetes à l’aide de la commande suivante :

    kubectl get namespaces
    

    La sortie de la commande doit être :

    Namespace

  3. À partir du tableau de bord Kubernetes, déployez rbac.yaml dans l’espace de noms par défaut à l’aide de la commande suivante :

    kubectl create -f rbac.yaml 
    
  4. Déployez le contrôleur VIP CRD et IPAM pour attribuer automatiquement des adresses IP aux services Kubernetes. Utilisez la commande suivante :

    kubectl create -f vip.yaml
    kubectl create -f ipam_deploy.yaml
    
  5. Déployez le Citrix ADC CPX pour les microservices hotdrink, colddrink, et guestbook à l’aide des commandes suivantes :

    kubectl create -f cpx.yaml -n tier-2-adc
    kubectl create -f hotdrink-secret.yaml -n tier-2-adc
    
  6. Déployez trois types de microservices de boissons hotdrink à l’aide des commandes suivantes :

    kubectl create -f team_hotdrink.yaml -n team-hotdrink
    kubectl create -f hotdrink-secret.yaml -n team-hotdrink
    
  7. Déployez le microservice de boissons colddrink à l’aide des commandes suivantes :

    kubectl create -f team_colddrink.yaml -n team-colddrink
    kubectl create -f colddrink-secret.yaml -n team-colddrink
    
  8. Déployez le microserviceguestbook à l’aide des commandes suivantes :

    kubectl create -f team_guestbook.yaml -n team-guestbook
    
  9. Ouvrez une session sur Citrix ADC de niveau 1 pour vérifier que la configuration n’est pas poussée à partir du Citrix ingress controller avant d’automatiser Citrix ADC de niveau 1.

  10. Déployez le Citrix ingress controller pour transmettre automatiquement la configuration Citrix ADC CPX au Citrix ADC de niveau 1. Dans cic_vpx.yaml, modifiez la valeur de la variable d’environnement NS_IP avec l’adresse IP NS de votre Citrix ADC VPX. Pour plus d’informations sur le déploiement du Citrix ingress controller, consultez Déployer le Citrix ingress controller à l’aide de YAML.

    Après avoir mis à jour le fichier cic_vpx.yaml, déployez-le à l’aide de la commande suivante :

    kubectl create -f cic_vpx.yaml -n tier-2-adc
    
  11. Vérifiez si le contrôleur IPAM a attribué des adresses IP aux services Citrix ADC CPX à l’aide de la commande suivante :

    kubectl get svc -n tier-2-adc

  12. Ajoutez les entrées DNS suivantes dans les fichiers hôtes de votre machine locale pour accéder aux microservices via Internet :

     <frontend-ip from ingress_vpx.yaml> hotdrink.beverages.com
     <frontend-ip from ingress_vpx.yaml> colddrink.beverages.com
     <frontend-ip from ingress_vpx.yaml> guestbook.beverages.com
    

Vous pouvez désormais accéder aux microservices à l’aide de l’URL suivante : https://hotdrink.beverages.com

Services de café et de thé

Variables d’environnement : contrôleur IPAM

Cette section fournit des informations sur les variables d’environnement du contrôleur IPAM.

VIP_RANGE

La variable d’environnement VIP_RANGE vous permet de définir la plage d’adresses IP. Vous pouvez définir une plage d’adresses IP ou une plage d’adresses IP associée à un nom unique.

Plage d’adresses IP

Vous pouvez définir la plage d’adresses IP à partir d’un ou de plusieurs sous-réseaux. Vous pouvez également utiliser le caractère - pour définir la plage d’adresses IP. Le contrôleur IPAM attribue l’adresse IP de cette plage d’adresses IP au service.

Les exemples suivants illustrent les différentes manières dont vous pouvez définir la plage d’adresses IP dans la variable d’environnement VIP_RANGE:

To define the IP address range from a subnet:

    - name: "VIP_RANGE"
      value: '["10.xxx.xxx.18/31"]'

To define the IP address range from multiple subnets, ensure that the values are valid CIDRs for the subnets:

    - name: "VIP_RANGE"
      value: '["10.217.212.18/31",  "10.217.212.20/31", "10.217.212.16/30", "10.217.212.0/24"]'

Also, you can use dash (`-`) to define the IP address range:

    - name: "VIP_RANGE"
      value: '["10.217.212.18 - 10.217.212.21",  “10.217.212.27 - 10.217.212.31",  “10.217.213.24 - 10.217.213.32" ]'

Plage d’adresses IP associée à un nom unique

Vous pouvez attribuer un nom unique à la plage d’adresses IP et définir la plage dans la variable d’environnement VIP_RANGE. Cette méthode d’attribution de la plage d’adresses IP vous permet de différencier les plages d’adresses IP. Lorsque vous créez les services de type LoadBalancer vous pouvez utiliser l’annotation service.citrix.com/ipam-range de la définition de service pour spécifier la plage d’adresses IP à utiliser pour l’allocation d’adresses IP.

Par exemple, il existe trois domaines, à savoir DevTest, et Prod qui ont des charges de travail dédiées à gérer. Si chaque équipe souhaite disposer d’une plage d’adresses IP distincte pour équilibrer la charge du trafic des microservices, vous pouvez attribuer des noms uniques aux plages d’adresses IP. Vous pouvez ensuite définir les noms dans l’annotation service.citrix.com/ipam-range de votre définition de service. Le service défini par service.citrix.com/ipam-range = 'Dev' se voit attribuer une adresse IP de la plage d’adresses IP associée à Dev.

Les exemples suivants illustrent les différentes manières de définir la plage d’adresses IP associée à un nom unique dans la variable d’environnement VIP_RANGE :

    - name: "VIP_RANGE"
      value: '[{"Prod": ["10.1.2.0/24"]}, {"Test": ["10.1.3.0/24"]}, {"Dev": ["10.1.4.0/24", "10.1.5.0/24"]},["10.1.6.0/24"]]'

Vous pouvez également utiliser le caractère - pour définir la plage d’adresses IP :

    - name: "VIP_RANGE"
      value: '[{"Prod": ["10.1.2.0 - 10.1.2.255"]}, {"Test": ["10.1.3.0 - 10.1.3.255"]}, {"Dev": ["10.1.4.0/24", "10.1.5.0/24"]},["10.1.6.0/24"]]'

Voici un exemple de définition de service pour illustrer l’utilisation de l’annotation service.citrix.com/ipam-range. Dans cet exemple, l’annotation est utilisée pour allouer au service une adresse IP de la plage d’adresses IP associée Dev à un nom unique.

    apiVersion: v1
    kind: Service
    metadata:
      annotations:
        service.citrix.com/ipam-range: "Dev"
      name: apache
      labels:
        name: apache
    spec:
      externalTrafficPolicy: Local
      type: LoadBalancer
      selector:
        name: apache
      ports:
      - name: http
        port: 80
        targetPort: http
      selector:
        app: apache

VIP_NAMESPACES

La variable d’environnement VIP_NAMESPACES vous permet de définir le contrôleur IPAM pour qu’il fonctionne uniquement pour un ensemble d’espaces de noms. Le contrôleur IPAM alloue des adresses IP uniquement aux services créés à partir des espaces de noms spécifiés dans la variable d’environnement.

L’exemple suivant montre comment spécifier des espaces de noms dans la variable d’environnement VIP_NAMESPACES:

    - name: "VIP_NAMESPACES"
      value: 'default kube-system'

Le contrôleur IPAM alloue des adresses IP aux services créés à partir des espaces de noms default et kube-system.

Remarque :

Si vous n’utilisez pas la variable d’environnement VIP_NAMESPACES ou si vous ne définissez pas de valeur, le contrôleur IPAM alloue des adresses IP aux services créés à partir de tous les espaces de noms.