Création d'un équilibreur de charge de réseau Private Path

Vous pouvez utiliser un équilibreur de charge de réseau (NLB) de chemin privé uniquement avec un service de chemin privé. Créez le chemin privé NLB à partir de la page Load Balancers for VPC ou dans le cadre du processus de provisionnement du service Private Path. Vous pouvez créer un équilibreur de charge réseau Private Path à l'aide de la console, de l'interface de programmation, de l'API ou de Terraform.

Private Path permet aux fournisseurs de services d'activer et de gérer une connectivité privée pour les consommateurs de leur service hébergé. Le service Private Path nécessite un Private Path NLB pour établir une connexion sécurisée avec la passerelle Virtual Private Endpoint (VPE) de chaque consommateur. Pour plus d'informations, voir A propos des services de chemin privé.

Chemin privé Les NLB prennent en charge la fonction de plage de ports. Actuellement, tous les VPE connectés à un chemin privé NLB peuvent se connecter à n'importe quel port de la plage. Pour plus d'informations, voir Configuration des plages de ports de l'équilibreur de charge du réseau public.

Avant de commencer

Vérifiez les conditions suivantes pour vous assurer que votre NLB à chemin privé est correctement configuré :

  • Si vous ne disposez pas d'un VPC, créez-en un dans la même région que celle où vous souhaitez créer votre NLB Private Path. Utilisez la même région VPC pour le Private Path NLB et le service Private Path.
  • Créez vos instances de serveurs virtuels avant de créer un chemin privé NLB. Cela permet de s'assurer qu'il est pleinement opérationnel.
  • Assurez-vous que le VPC que vous avez sélectionné comporte au moins un sous-réseau.

Vous pouvez créer un équilibreur de charge réseau Private Path à l'aide de la console, de l'interface de programmation, de l'API ou de Terraform.

Création d'un équilibreur de charge réseau Private Path dans la console

Pour créer et configurer un « Network Load Balancer for VPC » dans la console IBM Cloud, procédez comme suit :

  1. Dans votre navigateur, ouvrez la console IBM Cloud et connectez-vous à votre compte.

  2. Sélectionnez l' icône Menu du menu Navigation, puis cliquez sur l'icône Infrastructure VPC > Réseau > Équilibreurs de charge.

  3. Cliquez sur Créer dans l'angle supérieur droit de la page.

  4. Pour le type d'équilibreur de charge, sélectionnez la vignette Equilibreur de charge de réseau (NLB).

  5. Dans la section Emplacement, modifiez les zones suivantes, si nécessaire.

    • Géographie: zone géographique dans laquelle vous souhaitez créer l'équilibreur de charge.
    • Région: région dans laquelle vous souhaitez créer l'équilibreur de charge.

  6. Dans la section Détails, indiquez les informations suivantes :

    • Nom: saisissez un nom pour l'équilibreur de charge, par exemple private-path-load-balancer.
    • Groupe de ressources : sélectionnez un groupe de ressources pour l'équilibreur de charge.
    • Mots-clés: (Facultatif) Ajoutez des mots-clés pour vous aider à organiser et à retrouver vos ressources. Vous pourrez ajouter d'autres balises ultérieurement. Pour plus d'informations, voir Utilisation d'étiquettes.
    • Balises de gestion des accès: (Facultatif) Ajoutez des balises de gestion des accès aux ressources pour faciliter l'organisation des relations de contrôle d'accès. key:value est le seul format pris en charge pour les étiquettes de gestion des accès. Pour plus d'informations, voir Contrôle de l'accès aux ressources à l'aide d'étiquettes.
    • Cloud privé virtuel: sélectionnez le cloud privé virtuel dans lequel vous souhaitez déployer l'équilibreur de charge.
    • Sous-réseau: sélectionnez un sous-réseau.
    • Type: Sélectionnez Private Path.

  7. Dans la section Pools de back-end, cliquez sur Créer un pool, spécifiez les informations suivantes, puis cliquez sur Créer. Vous pouvez créer un ou plusieurs pools.

    • Saisissez un nom unique pour le pool, par exemple « private-path-pool ».

    • Sélectionnez un protocole pour vos instances dans ce pool. Le protocole du pool doit correspondre au protocole de son écouteur associé. Par exemple, si l'écouteur est TCP, le protocole du pool doit être TCP.

    • Sélectionnez la méthode, qui est l'algorithme d'équilibrage de charge, parmi les options suivantes.

      • Permutation circulaire : réacheminez les demandes vers chaque instance, à tour de rôle. Toutes les instances reçoivent approximativement un nombre égal de connexions client.
      • Permutation circulaire pondérée : réacheminez les demandes vers chaque instance proportionnellement au poids qui lui est affecté. Par exemple, si vous disposez des instances A, B et C et que leurs poids respectifs sont 60, 60 et 30, les instances A et B reçoivent un nombre égal de connexions client et l'instance C reçoit la moitié de ce nombre.

    • Choisissez le maintien de la session et sélectionnez Aucun.

    • Entrez les options de diagnostic d'intégrité suivantes:

      • Chemin d'accès au contrôle d'intégrité- Le chemin d'accès au contrôle d'intégrité ne s'applique que si vous sélectionnez « HTTP » comme protocole de contrôle d'intégrité. Le chemin du diagnostic d'intégrité indique l'URL utilisée par l'équilibreur de charge pour envoyer des demandes de diagnostic d'intégrité HTTP aux instances du pool. Par défaut, les contrôles d'intégrité sont envoyés à la racine (/).

      • Protocole de santé : protocole utilisé par l'équilibreur de charge pour envoyer des messages de contrôle d'intégrité aux instances du pool.

      • Port de surveillance (facultatif)- Port sur lequel envoyer les requêtes de vérification de l'état de santé. Par défaut, les contrôles d'intégrité sont envoyés sur le même port que celui sur lequel le trafic est envoyé à l'instance.

      • Intervalle (sec)- Intervalle, exprimé en secondes, entre deux tentatives consécutives de vérification de l'état de santé.

      • Délai d'expiration (en secondes): durée maximale pendant laquelle le système attend une réponse à une requête de vérification de l'état de santé.

      • Nombre maximal de tentatives: nombre maximal de tentatives de vérification de l'état qu'effectue l'équilibreur de charge avant de déclarer une instance comme défaillante. Par défaut, une instance n'est plus considérée comme étant en bonne santé après deux échecs de contrôle d'intégrité.

        Bien que l'équilibreur de charge arrête d'envoyer des connexions aux instances en mauvaise santé, il continue de surveiller la santé de ces instances et les réutilise dès qu'elles sont à nouveau considérées comme étant en bonne santé (après deux tentatives de contrôle d'intégrité consécutives satisfaisantes).

      Si les instances du pool ne sont pas opérationnelles et que vous pensez que votre application fonctionne correctement, vérifiez à nouveau les valeurs du protocole de santé et du chemin de santé. Vérifiez également tout groupe de sécurité associé aux instances pour vous assurer que les règles autorisent le trafic entre l'équilibreur de charge et ces instances.

  8. (Facultatif) Sélectionnez « Paramètres de la requête » pour personnaliser les valeurs de la requête de vérification de l'état. Si aucune valeur n'est indiquée, les paramètres par défaut sont utilisés.

    • Méthode de requête: choisissez l'une des options suivantes : GET ou POST. Vous pouvez personnaliser les en-têtes de requête pour ces deux méthodes. Vous pouvez, si vous le souhaitez, personnaliser le corps de la requête lorsque vous utilisez la méthode POST.
    • Corps de la requête: incluez le corps de la requête HTTP à utiliser pour les contrôles d'intégrité. Si aucun corps de requête n'est spécifié, les requêtes de vérification de l'état de santé n'en comporteront pas.
    • En-tête d'hôte: inclure l'en-tête d'hôte pour s'assurer que la requête utilise le protocole HTTP/1.1. Sinon, le système utilise par défaut l'adresse HTTP/1.0.
    • Ajouter d'autres en-têtes de requête: ajoutez un ou plusieurs en-têtes de requête supplémentaires.
    • Nom de l'en-tête: pour la méthode de requête « GET », choisissez l'une des valeurs suivantes : content-type, accept, authorization, cookie, origin, referrer ou user-agent. Pour la méthode de requête « POST », choisissez l'une des options suivantes : content-type, content-length, application-json ou accept-encoding.
    • Valeur: saisissez la valeur correspondant au nom d'en-tête indiqué.

    En ce qui concerne les équilibreurs de charge du réseau de chemins privés (PPNLB), il existe un problème connu : les champs de requête et de réponse du moniteur d'intégrité ne sont pas renvoyés dans la réponse de l'API GET.

  9. (Facultatif) Sélectionnez « Paramètres de réponse » pour personnaliser les valeurs de réponse du contrôle d'intégrité. Si aucune valeur n'est indiquée, les paramètres par défaut sont utilisés.

    • Corps de la réponse: saisissez le texte du corps de la réponse.

    • Code de réponse: vous pouvez indiquer plusieurs valeurs séparées par des virgules comprises entre 100 et 599. Pour définir une plage, utilisez XX. Par exemple, 2XX pour la fourchette 200-299.

      HTTP envoie les données sous forme de texte clair, ce qui peut permettre leur interception et est considéré comme peu sûr. Il est recommandé d'utiliser le protocole https plutôt que http. Pour plus d'informations, consultez la rubrique « Pourquoi le site HTTP n'est-il pas sécurisé? ».

      Bien que l'équilibreur de charge arrête d'envoyer des connexions aux instances en mauvaise santé, il continue de surveiller la santé de ces instances et les réutilise dès qu'elles sont à nouveau considérées comme étant en bonne santé (après deux tentatives de contrôle d'intégrité consécutives satisfaisantes).

      Si des instances du pool sont en mauvaise santé et que vous pensez que votre application s'exécute correctement, vérifiez les valeurs de protocole de santé et de chemin de santé. Vérifiez également tout groupe de sécurité associé aux instances pour vous assurer que les règles autorisent le trafic entre l'équilibreur de charge et ces instances.

  10. Vous pouvez attacher des membres à votre pool back-end dès maintenant ou après avoir créé votre Private Path NLB. Cliquez sur Attach dans la ligne de tableau de votre pool back-end. Indiquez les informations suivantes, puis cliquez sur « Joindre ».

    • Type de membre: Ajoutez des instances de serveurs virtuels, des IP réservées ou un équilibreur de charge d'application en tant que membre. Pour les instances de serveurs virtuels, attachez chaque type individuellement. Un membre IP réservé peut être lié à un serveur bare metal, à une interface primaire ou secondaire d'une instance de serveur virtuel ou à une interface de réseau virtuel.

      Si vous attachez un ALB en tant que cible membre à un pool NLB Private Path, aucun autre membre ne peut être ajouté à ce pool.

    • Sous-réseau: Choisissez un sous-réseau.

    • Dans la liste des serveurs, sélectionnez les serveurs à connecter au pool de back-end. Veillez à spécifier des valeurs valides pour chaque port de serveur.

      Votre équilibreur de charge Private Path offre une disponibilité régionale et résiste aux pannes de zone, même si un seul sous-réseau est sélectionné.

    Il n'est pas nécessaire de créer plusieurs équilibreurs de charge Private Path ou de spécifier plus d'un seul sous-réseau pour garantir la résilience en cas de défaillance d'une zone. Votre sélection de sous-réseau n'a d'impact que sur les adresses IP associées à l'équilibreur de charge. Pour plus d'informations sur le nombre d'instances de serveurs virtuels que vous pouvez attacher à un pool back-end, voir Quotas et limites de service pour les équilibreurs de charge du réseau Private Path.

    Vous pouvez modifier les membres joints en cliquant sur l'icône Modifier dans la ligne du membre que vous souhaitez modifier dans le tableau des pools back-end. Vous pouvez également supprimer des membres attachés en sélectionnant l'icône moins dans la ligne du membre que vous souhaitez supprimer.

  11. Dans la section Auditeurs frontaux, cliquez sur Créer, spécifiez les informations suivantes, puis cliquez sur Créer. Vous pouvez créer un ou plusieurs écouteurs.

    • Pool de serveurs arrière par défaut: le pool de serveurs arrière par défaut vers lequel ce listener transfère le trafic.
    • Protocole d'écoute- Protocole à utiliser pour recevoir les requêtes entrantes ( TCP ).
    • Port d'écoute- Le port sur lequel les requêtes sont reçues.

  12. Vérifiez le récapitulatif de votre commande, puis cliquez sur « Créer » pour valider votre commande.

Création d'un équilibreur de charge réseau Private Path à partir de l'interface de ligne de commande

L'exemple suivant illustre la création d'un chemin privé NLB à partir de l'interface de gestion. Dans cet exemple, le NLB à chemin privé est placé en amont d’une instance de serveur virtuel VPC (ID 0716_6acdd058-4607-4463-af08-d4999d983945) exécutant un serveur TCP qui écoute sur le port 9090. L'équilibreur de charge dispose d'un écouteur de front-end, qui permet un accès sécurisé au serveur TCP.

Pour créer un chemin privé NLB à partir de l'interface de commande, procédez comme suit :

  1. Configurez votre environnement d'interface de ligne de commande.

  2. Connectez-vous à votre compte via l'interface CLI. Une fois le mot de passe saisi, le système vous invite à choisir le compte et la région que vous souhaitez utiliser :

    ibmcloud login --sso

  3. Créer un NLB à chemin d'accès privé :

    ibmcloud is load-balancer-create ppnlb-test private-path --subnet cli-subnet-1 --family network

    Exemple de sortie :

    Creating load balancer ppnlb-test in resource group under account IBM Cloud Network Services as user test@ibm.com...

 ID
 Name               ppnlb-test
 CRN
 Family             Network
 Host name
 Subnets            ID                                          Name
                                                                cli-subnet-2

 Public IPs
 Reserved IPs         ID                                          Address        Subnet

 Provision status   create_pending
 Operating status   offline
 Is public          false
 Is private path    true
 Listeners
 Pools              ID                                 Name
                                                       my-pool
 Resource group     ID                                 Name
                                                       Default

 Created            2025-01-10T15:07:53+05:30
 Availability                 region
 Instance Group Supported     false
 SourceIP Session Supported   false
 Security groups supported    false
 UDP Supported                false
 Access mode                  private_path

  4. Créez un pool :

    ibmcloud is load-balancer-pool-create my-pool pp-nlb-test round_robin tcp 20 2 5 http

    Exemple de sortie :

    Creating pool my-pool of load balancer my-pool under account IBM Cloud Network Services as user test@ibm.com...

ID
Name                       my-pool
Protocol                   tcp
Algorithm                  round_robin
Instance group             ID   Name
                           -    -
Proxy protocol        disabled
Health monitor             Type   Port   Health monitor URL   Delay   Retries   Timeout
                           http   -      /                    20      2         5

Session persistence type   Type   Cookie name
                           -      -

Members
Provision status           create_pending
Created                    2025-01-10T20:44:57+05:30

  5. Créez un membre :

    ibmcloud is load-balancer-pool-member-create test-ppnlb-1 test 3000 my-target

    Un utilisateur peut créer un chemin privé NLB ciblant une instance de serveur virtuel, une IP réservée ou un équilibreur de charge d'application (ALB). Créez un membre avec my-target en tant que my-instance ou my-alb.

    Exemple de sortie :

    Creating member of pool test under account IBM Cloud Network Services as user test@ibm.com...

ID                 test
Port               3000
Target             10.240.66.14
Weight             50
Health             unknown
Created            0001-01-01T05:53:28+05:53
Provision status   create_pending

  6. Créez un programme d'écoute :

    ibmcloud is load-balancer-listener-create ppnlb-test --port-min 443 --protocol tcp

    Exemple de sortie :

    Creating listener of load balancer ppnlb-test under account IBM Cloud Network Services as user test@ibm.com...

ID
Certificate instance      -
Connection limit          -
Ports                     443
Idle connection timeout   -
Protocol                  tcp
Default pool              -
Accept proxy protocol     false
Provision status          create_pending
Created                   2025-01-10T21:02:37+05:30

  7. Extrayez les détails de votre équilibreur de charge :

    ibmcloud is load-balancer ppnlb-test

    Exemple de sortie :

    Getting load balancer ppnlb-test under account IBM Cloud Network Services as user test@ibm.com...

ID
Name               ppnlb-test
CRN
Family             Network
Host name
Subnets            ID                                          Name
                                                               nlb

Public IPs
Reserved IPs       ID                                          Address        Subnet
Provision status   active
Operating status   online
Is public          false
Is private path    true
Listeners
Pools              ID                                          Name
                                                               my-pool

Resource group     ID                                 Name
                                                      Default

Created                      2025-01-10T15:07:53+05:30
Availability                 region
Instance Group Supported     false
SourceIP Session Supported   false
Security groups supported    false
UDP Supported                false
Access mode                  private_path

Création d'un équilibreur de charge réseau à l'aide de l'API

L'exemple suivant illustre la création d'un chemin privé NLB avec l'API. L'équilibreur de charge de réseau détaillé ici se trouve devant deux instances de serveur virtuel VPC (192.168.100.5 et 192.168.100.6) exécutant une application Web qui écoute sur le port 80. Elle dispose d'un écouteur frontal qui permet un accès sécurisé à l'application web via HTTPS.

Cet exemple ne couvre pas les étapes préalables à l'utilisation de l'API pour provisionner un VPC, des sous-réseaux et des instances.

Pour créer un chemin privé NLB avec l'API, procédez comme suit :

  1. Configurez votre environnement d'API.

  2. Stockez les valeurs suivantes dans les variables destinées à être utilisées dans la commande d'API :

    • subnetId-D'abord, obtenez votre sous-réseau, puis renseignez la variable:
    export subnetId=<your_subnet_id>
    • targetId- Deuxièmement, obtenez l'instance de serveur virtuel, l'IP réservée ou l'équilibreur de charge d'application (ALB) qui se trouve dans le même VPC que le sous-réseau :
    export targetId=<your_target_id>

  3. Créer un NLB « Private Path » avec un écouteur, un pool et des instances de serveur associées (membres du pool):

    curl -H "Authorization: Bearer $iam_token" -X POST
"$vpc_api_endpoint/v1/load_balancers?version=$api_version&generation=2" \
    -d '{
     "is_public": false,
     "is_private_path": true,
     "name": "my-load-balancer",
     "listeners": [
         {
             "default_pool": {
                 "name": "my-pool"
             },
             "port_min": 80,
             "port_max": 80,
             "protocol": "tcp"
         }
     ],
     "subnets": [
         {
             "id" : "$subnetId"
         }
     ],
     "pools": [
         {
             "algorithm": "round_robin",
             "health_monitor": {
                 "delay": 2,
                 "max_retries": 1,
                 "timeout": 1,
                 "port": 80,
                 "type": "tcp"
             },
             "name": my-pool",
             "protocol": "tcp",
             "members" : [
                 {
                     "port" : 80,
                     "target" : {"id" : "$targetId"}
                 }
             ]
         }
     ],
     "profile": {
         "name": "network-private-path"
     }
 }'

    Exemple de sortie :

         {
         "availability": "region",
         "created_at": "2023-09-22T21:49:26.000Z",
         "crn": "crn:v1:bluemix:public:is:au-syd:a/b21af5a9874242b7851e780943d595a9::load-balancer:r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "hostname": ".invalid",
         "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "id": "r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "instance_groups_supported": false,
         "is_private_path": true,
         "is_public": false,
         "listeners": [
             {
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413/listeners/r026-00b18a00-d860-4f4d-bb84-e29ffc2d8e47",
                 "id": "r026-00b18a00-d860-4f4d-bb84-e29ffc2d8e47"
             }
         ],
         "logging": {
             "datapath": {
                 "active": false
             }
         },
         "name": "my-load-balancer",
         "operating_status": "offline",
         "pools": [
             {
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413/pools/r026-f25e3f26-3aa6-4aef-9108-1587d3ac6679",
                 "id": "r026-f25e3f26-3aa6-4aef-9108-1587d3ac6679",
                 "name": "my-pool"
             }
         ],
         "private_ips": [
             {
                 "address": "10.245.0.4",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-e21d477e-3e71-47fc-aec4-9703766cf652",
                 "id": "02h7-e21d477e-3e71-47fc-aec4-9703766cf652",
                 "name": "nugget-ounce-stability-vocation",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.5",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-1910c529-dadd-4960-aba5-3c4604f99f56",
                 "id": "02h7-1910c529-dadd-4960-aba5-3c4604f99f56",
                 "name": "impostors-synopses-uncivic-livable",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.6",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-a7e55150-5b02-426f-b1dc-aa136effc6ce",
                 "id": "02h7-a7e55150-5b02-426f-b1dc-aa136effc6ce",
                 "name": "unmade-garnish-preview-defame",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.7",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-ae009701-8301-420c-862e-a9ec1f79214c",
                 "id": "02h7-ae009701-8301-420c-862e-a9ec1f79214c",
                 "name": "slacking-scuttle-stonework-reptile",
                 "resource_type": "subnet_reserved_ip"
             }
         ],
         "profile": {
             "family": "network",
             "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancer/profiles/network-private-path",
             "name": "network-private-path"
         },
         "provisioning_status": "create_pending",
         "public_ips": [],
         "resource_group": {
             "href": "https://resource-controller.cloud.ibm.com/v2/resource_groups/297468d87ca047c5be28368e52b055ce",
             "id": "297468d87ca047c5be28368e52b055ce",
             "name": "Default"
         },
         "resource_type": "load_balancer",
         "route_mode": false,
         "security_groups": [],
         "security_groups_supported": false,
         "source_ip_session_persistence_supported": false,
         "subnets": [
             {
                 "crn": "crn:v1:bluemix:public:is:au-syd-1:a/b21af5a9874242b7851e780943d595a9::subnet:02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "id": "02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "name": "my-subnet",
                 "resource_type": "subnet"
             }
         ],
         "udp_supported": false
     }

    Enregistrez l'ID de l'équilibreur de charge pour l'utiliser dans les étapes suivantes. Sauvegardez-le, par exemple, dans la variable lbid.

    lbid=0738-dd754295-e9e0-4c9d-bf6c-58fbc59e5727

  4. Obtenir des informations sur l'équilibreur de charge Private Path :

     curl -H "Authorization: Bearer $iam_token" -X GET "$vpc_api_endpoint/v1/load_balancers/$lbid?version=$api_version&generation=2"

    Prévoir un délai pour l'approvisionnement. Quand l'équilibreur de charge est prêt, son statut est défini à online et active, comme illustré dans la sortie exemple suivante :

         {
         "availability": "region",
         "created_at": "2023-09-22T21:49:26.000Z",
         "crn": "crn:v1:bluemix:public:is:au-syd:a/b21af5a9874242b7851e780943d595a9::load-balancer:r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "hostname": ".invalid",
         "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "id": "r026-d-86b51a9e-a058-4317-beed-8ee581a1f413",
         "instance_groups_supported": false,
         "is_private_path": true,
         "is_public": false,
         "listeners": [
             {
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413/listeners/r026-00b18a00-d860-4f4d-bb84-e29ffc2d8e47",
                 "id": "r026-00b18a00-d860-4f4d-bb84-e29ffc2d8e47"
             }
         ],
         "logging": {
             "datapath": {
                 "active": false
             }
         },
         "name": "my-load-balancer",
         "operating_status": "only",
         "pools": [
             {
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancers/r026-d-86b51a9e-a058-4317-beed-8ee581a1f413/pools/r026-f25e3f26-3aa6-4aef-9108-1587d3ac6679",
                 "id": "r026-f25e3f26-3aa6-4aef-9108-1587d3ac6679",
                 "name": "my-pool"
             }
         ],
         "private_ips": [
             {
                 "address": "10.245.0.4",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-e21d477e-3e71-47fc-aec4-9703766cf652",
                 "id": "02h7-e21d477e-3e71-47fc-aec4-9703766cf652",
                 "name": "nugget-ounce-stability-vocation",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.5",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-1910c529-dadd-4960-aba5-3c4604f99f56",
                 "id": "02h7-1910c529-dadd-4960-aba5-3c4604f99f56",
                 "name": "impostors-synopses-uncivic-livable",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.6",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-a7e55150-5b02-426f-b1dc-aa136effc6ce",
                 "id": "02h7-a7e55150-5b02-426f-b1dc-aa136effc6ce",
                 "name": "unmade-garnish-preview-defame",
                 "resource_type": "subnet_reserved_ip"
             },
             {
                 "address": "10.245.0.7",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02/reserved_ips/02h7-ae009701-8301-420c-862e-a9ec1f79214c",
                 "id": "02h7-ae009701-8301-420c-862e-a9ec1f79214c",
                 "name": "slacking-scuttle-stonework-reptile",
                 "resource_type": "subnet_reserved_ip"
             }
         ],
         "profile": {
             "family": "network",
             "href": "https://au-syd.iaas.cloud.ibm.com/v1/load_balancer/profiles/network-private-path",
             "name": "network-private-path"
         },
         "provisioning_status": "active",
         "public_ips": [],
         "resource_group": {
             "href": "https://resource-controller.cloud.ibm.com/v2/resource_groups/297468d87ca047c5be28368e52b055ce",
             "id": "297468d87ca047c5be28368e52b055ce",
             "name": "Default"
         },
         "resource_type": "load_balancer",
         "route_mode": false,
         "security_groups": [],
         "security_groups_supported": false,
         "source_ip_session_persistence_supported": false,
         "subnets": [
             {
                 "crn": "crn:v1:bluemix:public:is:au-syd-1:a/b21af5a9874242b7851e780943d595a9::subnet:02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "href": "https://au-syd.iaas.cloud.ibm.com/v1/subnets/02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "id": "02h7-ee9114e7-28d4-4416-bbfa-f274dbd49f02",
                 "name": "my-subnet",
                 "resource_type": "subnet"
             }
         ],
         "udp_supported": false
     }

Création d'un équilibreur de charge réseau Private Path avec Terraform

L'exemple suivant crée un équilibreur de charge réseau Private Path avec Terraform :

  1. Créer un NLB à chemin d'accès privé :

    resource "ibm_is_lb" "example_ppnlb" {
  name    = "example-ppnlb"
  subnets = [ibm_is_subnet.example_subnet.id]
  profile = "network-private-path"
  type    = "private_path"
}

  2. En option, créez un pool pour votre Private Path NLB :

    resource "ibm_is_lb_pool" "example_pool" {
  name            = "example-pool"
  lb              = [ibm_is_lb.example_ppnlb.id]
  algorithm       = "round_robin"
  protocol        = "tcp"
  health_delay    = 2
  health_retries  = 2
  health_timeout  = 1
  health_type     = "tcp"
}

  3. En option, ciblez un ALB ou un ID d'instance de serveur virtuel en tant que membre du pool pour votre Private Path NLB :

    resource "ibm_is_lb" "example_alb" {
  name    = "example-alb"
  subnets = [ibm_is_subnet.example_subnet.id]
}

    resource "ibm_is_lb_pool_member" "example_member" {
  lb        = [ibm_is_lb.example_ppnlb.id]
  pool      = element(split("/", ibm_is_lb_pool.example_pool.id), 1)
  port      = 8080
  weight    = 20
  target_id = [ibm_is_lb.example_alb.id]
}

  4. En option, ciblez une IP réservée comme membre du pool pour votre Private Path NLB :

    resource "ibm_is_subnet_reserved_ip" "example" {
subnet = ibm_is_subnet.example.id
}

    resource "ibm_is_lb_pool_member" "example" {
  lb        = ibm_is_lb.example_ppnlb.id
  pool      = element(split("/", ibm_is_lb_pool.example.id), 1)
  port      = 8080
  weight    = 20
  target_id = ibm_is_subnet_reserved_ip.example.id
}

Pour consulter la documentation relative aux ressources Terraform, rendez-vous sur le Terraform Registry.