Creazione di un bilanciatore di carico di rete Private Path

Puoi utilizzare un NLB (network load balancer) del percorso privato solo con un servizio Percorso privato. Creare il Private Path NLB dalla pagina Load Balancer per VPC o come parte del processo di provisioning del servizio Private Path. È possibile creare un bilanciatore di carico di rete Private Path utilizzando la console, la CLI, le API o Terraform.

Private Path consente ai fornitori di servizi di attivare e gestire la connettività privata per gli utenti dei loro servizi in hosting. Il servizio Private Path richiede che un NLB Private Path stabilisca una connessione sicura con il gateway Virtual Private Endpoint (VPE) di ciascun utente. Per ulteriori informazioni, consulta Informazioni sui servizi del percorso privato.

I percorsi privati NLB supportano la funzione di intervallo di porte. Attualmente, tutti i VPE connessi a un percorso privato NLB possono connettersi a qualsiasi porta dell'intervallo. Per ulteriori informazioni, vedere Impostazione degli intervalli di porte del bilanciatore di carico della rete pubblica.

Prima di iniziare

Verifica i seguenti requisiti per assicurarti che il tuo NLB con percorso privato sia configurato correttamente:

  • Se non si dispone di un VPC, crearne uno nella stessa regione in cui si desidera creare il Private Path NLB. Utilizza la stessa regione VPC per il servizio Private Path NLB e Private Path.
  • Creare le istanze del server virtuale prima di creare un percorso privato NLB. In questo modo si garantisce la piena operatività.
  • Assicurati di avere almeno una sottorete nella VPC selezionata.

È possibile creare un bilanciatore di carico di rete Private Path utilizzando la console, la CLI, le API o Terraform.

Creazione di un bilanciatore di carico di rete Private Path nella console

Per creare e configurare Network Load Balancer for VPC nella console IBM Cloud, attieniti alla seguente procedura:

  1. Dal browser, apri la console IBM Cloud ed effettua l'accesso al tuo account.

  2. Selezionare l' icona Menu del menu di navigazione, quindi fare clic sull'icona Infrastruttura VPC > Rete > Bilanciatori di carico.

  3. Fare clic su Crea in alto a destra della pagina.

  4. Per il tipo di bilanciamento del carico, seleziona il tile Network Load Balancer (NLB).

  5. Nella sezione Ubicazione, modificare i seguenti campi, se necessario.

    • Geografia: l'area geografica in cui vuoi creare il programma di bilanciamento del carico.
    • Regione: la regione in cui vuoi creare il programma di bilanciamento del carico.

  6. Nella sezione "Dettagli", inserisci le seguenti informazioni:

    • Nome: inserire un nome per il bilanciatore di carico, ad esempio private-path-load-balancer.
    • Resource group: seleziona un gruppo di risorse per il programma di bilanciamento del carico.
    • Tag: (Facoltativo) Aggiungi dei tag per organizzare e trovare più facilmente le tue risorse. Puoi aggiungere più tag in seguito. Per ulteriori informazioni, vedi Gestione delle tag.
    • Tag di gestione degli accessi: (facoltativo) aggiungere tag di gestione degli accessi alle risorse per organizzare le relazioni di controllo degli accessi. L'unico formato supportato per le tag di gestione accessi è key:value. Per ulteriori informazioni, vedi Controllo dell'accesso alle risorse utilizzando le tag.
    • Virtual private cloud: seleziona il VPC in cui vuoi distribuire il programma di bilanciamento del carico.
    • Sottorete: selezionare una sottorete.
    • Type: Selezionare Private Path.

  7. Nella sezione Pool di back-end, fare clic su Crea pool, specificare le seguenti informazioni, quindi fare clic su Crea. Puoi creare uno o più pool.

    • Immettere un nome univoco per il pool, ad esempio private-path-pool.

    • Seleziona un protocollo per le tue istanze in questo pool. Il protocollo del pool deve corrispondere al protocollo del listener associato. Ad esempio, se il listener è TCP, il protocollo del pool deve essere TCP.

    • Selezionare il metodo, che è l'algoritmo di bilanciamento del carico, tra le seguenti opzioni.

      • Round robin- Inoltra le richieste a ciascuna istanza a turno. Tutte le istanze ricevono approssimativamente un numero uguale di connessioni client.
      • Round robin ponderato- Inoltra le richieste a ciascuna istanza in proporzione al peso assegnatole. Ad esempio, se si dispone delle istanze A, B e C e i relativi pesi sono impostati su 60, 60 e 30, le istanze A e B ricevono un numero uguale di connessioni e l'istanza C riceve la metà del numero di connessioni.

    • Scegliere la permanenza della sessione e selezionare Nessuno.

    • Immettere le opzioni di controllo integrità riportate di seguito:

      • Percorso del controllo di integrità- Il percorso del controllo di integrità è applicabile solo se si seleziona " HTTP " come protocollo di controllo di integrità. Il percorso del controllo di integrità specifica l' URL utilizzato dal bilanciatore di carico per inviare le richieste di controllo di integrità HTTP alle istanze presenti nel pool. Per impostazione predefinita, i controlli di integrità vengono inviati al percorso root (/).

      • Protocollo di integrità- Il protocollo utilizzato dal bilanciatore di carico per inviare messaggi di controllo dell'integrità alle istanze presenti nel pool.

      • Porta di integrità (opzionale)- La porta su cui inviare le richieste di controllo dell'integrità. Per impostazione predefinita, i controlli di integrità vengono inviati sulla stessa porta su cui viene inviato il traffico all'istanza.

      • Intervallo (sec)- L'intervallo in secondi tra due tentativi consecutivi di controllo dello stato di salute.

      • Timeout (sec)- Il tempo massimo che il sistema attende per ricevere una risposta a una richiesta di controllo dello stato di funzionamento.

      • Numero massimo di tentativi: il numero massimo di tentativi di controllo dello stato che il bilanciatore di carico effettua prima che un'istanza venga dichiarata non funzionante. Per impostazione predefinita, un'istanza non è più considerata integra dopo due controlli di integrità non riusciti.

        Sebbene il programma di bilanciamento del carico interrompa l'invio di connessioni a istanze non integre, il programma di bilanciamento del carico continua a monitorare l'integrità di queste istanze e ne ripristina l'utilizzo se vengono rilevate nuovamente integre (ovvero, se superano correttamente due tentativi consecutivi di controllo di integrità).

      Se le istanze nel pool non sono in buono stato e ritieni che la tua applicazione funzioni correttamente, ricontrolla i valori del protocollo di integrità e del percorso di integrità. Inoltre, controlla tutti i gruppi di sicurezza collegati alle istanze per assicurati che le regole consentano il traffico tra il programma di bilanciamento del carico e le istanze.

  8. (Facoltativo) Selezionare " Impostazioni richiesta " per personalizzare i valori della richiesta di controllo dello stato. Se non vengono specificati valori, vengono utilizzate le impostazioni predefinite.

    • Metodo di richiesta: scegliere uno tra GET o POST. È possibile personalizzare le intestazioni delle richieste per entrambi i metodi. È possibile, se lo si desidera, personalizzare il corpo della richiesta quando si utilizza il metodo POST.
    • Corpo della richiesta: includere il corpo della richiesta HTTP da utilizzare per i controlli di integrità. Se non diversamente specificato, le richieste di health check non avranno un corpo della richiesta.
    • Intestazione host: includere l'intestazione host per garantire che la richiesta utilizzi il protocollo HTTP/1.1. In caso contrario, il sistema imposta come valore predefinito HTTP/1.0.
    • Aggiungi altre intestazioni di richiesta: aggiungi una o più intestazioni di richiesta aggiuntive.
    • Nome dell'intestazione: per il metodo di richiesta " GET ", scegliere una delle seguenti opzioni: content-type, accept, authorization, cookie, origin, referrer o user-agent. Per il metodo di richiesta " POST ", scegliere una delle seguenti opzioni: content-type, content-length, application-json o accept-encoding.
    • Valore: inserire il valore corrispondente al nome dell'intestazione specificato.

    Per i bilanciatori di carico di rete Private Path (PPNLB), è presente un problema noto per cui i campi relativi alla richiesta e alla risposta del monitoraggio dello stato non vengono restituiti nella risposta dell'API GET.

  9. (Facoltativo) Selezionare " Impostazioni di risposta " per personalizzare i valori di risposta del controllo di integrità. Se non vengono specificati valori, vengono utilizzate le impostazioni predefinite.

    • Corpo della risposta: inserisci il testo del corpo della risposta.

    • Codice di risposta: È possibile specificare più valori separati da virgole compresi nell'intervallo 100-599. Per specificare un intervallo, utilizzare XX. Ad esempio, 2XX per i modelli da 200 a 299.

      HTTP invia i dati in formato testo semplice, che può essere intercettato ed è considerato non sicuro. Si consiglia di utilizzare il protocollo https anziché http. Per ulteriori dettagli, consulta la sezione " Perché HTTP non è sicuro? ".

      Sebbene il programma di bilanciamento del carico interrompa l'invio di connessioni a istanze non integre, il programma di bilanciamento del carico continua a monitorare l'integrità di queste istanze e ne ripristina l'utilizzo se vengono rilevate nuovamente integre (ovvero, se superano correttamente due tentativi consecutivi di controllo di integrità).

      Se le istanze nel pool non sono integre e ritieni che la tua applicazione funzioni correttamente, ricontrolla i valori del protocollo di integrità e del percorso di integrità. Inoltre, controlla tutti i gruppi di sicurezza collegati alle istanze per assicurati che le regole consentano il traffico tra il programma di bilanciamento del carico e le istanze.

  10. È possibile collegare i membri al pool back-end ora o dopo aver creato il Private Path NLB. Fare clic su Allega nella riga della tabella del pool di back-end. Specificare le seguenti informazioni, quindi fare clic su Allega.

    • Tipo di membro: Aggiungere istanze di server virtuali, IP riservati o un bilanciatore di carico delle applicazioni come membro. Per le istanze server virtuali, collegare ogni tipo singolarmente. Un membro IP riservato può essere legato a un server bare metal, a un'interfaccia primaria o secondaria di un'istanza di server virtuale o a un'interfaccia di rete virtuale.

      Se si collega un ALB come target membro a un pool NLB Private Path, non è possibile aggiungere altri membri a tale pool.

    • Subnet: scegli una sottorete.

    • Dall'elenco di server, selezionare i server che si desidera collegare al pool di backend. Assicurarsi di specificare valori validi per ogni porta server.

      Il bilanciatore di carico di Private Path garantisce la disponibilità a livello regionale ed è resiliente ai guasti a livello di zona anche se viene selezionata una singola sottorete.

    Non è necessario creare più bilanciatori di carico Private Path o specificare più di una singola subnet per garantire la resilienza ai guasti della zona. La selezione della sottorete influisce solo sugli indirizzi IP associati al bilanciatore di carico. Per ulteriori informazioni sul numero di istanze di server virtuali che è possibile collegare a un pool back-end, vedere Quote e limiti di servizio per i bilanciatori di carico di rete Private Path.

    Puoi modificare i membri collegati facendo clic sull'icona Modifica nella riga del membro che desideri modificare nella tabella dei pool di back-end. È inoltre possibile eliminare i membri collegati selezionando l'icona meno nella riga del membro che si desidera eliminare.

  11. Nella sezione Front-end listeners (Ascoltatore front-end), fare clic su Create (Crea ), specificare le seguenti informazioni, quindi fare clic su Create (Crea ). Puoi creare uno o più listener.

    • Pool di back-end predefinito- Il pool di back-end predefinito a cui questo listener inoltra il traffico.
    • Protocollo di ascolto- Il protocollo da utilizzare per ricevere le richieste in arrivo ( TCP ).
    • Porta di ascolto- La porta su cui vengono ricevute le richieste.

  12. Controlla il riepilogo dell'ordine, quindi fai clic su " Crea " per completare l'ordine.

Creazione di un bilanciatore di carico di rete Private Path dalla CLI

L'esempio seguente mostra la creazione di un percorso privato NLB dalla CLI. In questo esempio, il Private Path NLB è collegato a un'istanza di server virtuale VPC (ID 0716_6acdd058-4607-4463-af08-d4999d983945) su cui è in esecuzione un server TCP in ascolto sulla porta 9090. Il bilanciatore di carico dispone di un listener front-end che consente l'accesso sicuro al server TCP.

Per creare un percorso privato NLB dalla CLI, procedere come segue:

  1. Imposta il tuo ambiente CLI.

  2. Accedi al tuo account tramite la CLI. Dopo aver inserito la password, il sistema richiede di scegliere l'account e la regione che si desidera utilizzare:

    ibmcloud login --sso

  3. Creare un NLB con percorso privato:

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

    Output di esempio:

    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. Creare un pool:

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

    Output di esempio:

    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. Creare un membro:

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

    Un utente può creare un percorso privato NLB mirato a un'istanza di server virtuale, a un IP riservato o a un bilanciatore di carico delle applicazioni (ALB). Creare un membro con my-target come my-instance o my-alb.

    Output di esempio:

    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. Creare un listener:

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

    Output di esempio:

    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. Ottieni i dettagli sul tuo programma di bilanciamento del carico:

    ibmcloud is load-balancer ppnlb-test

    Output di esempio:

    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

Creazione di un programma di bilanciamento del carico di rete con l'API

L'esempio seguente illustra la creazione di un percorso privato NLB con l'API. L'NLB qui descritto si trova davanti a due istanze del server virtuale VPC (192.168.100.5 e 192.168.100.6) che eseguono un'applicazione web in ascolto sulla porta 80. Dispone di un listener front-end che consente l'accesso sicuro all'applicazione web tramite l'indirizzo HTTPS.

Questo esempio ignora la procedura prerequisita per utilizzare l'API per eseguire il provisioning di un VPC, delle sottoreti e delle istanze.

Per creare un percorso privato NLB con l'API, procedere come segue:

  1. Imposta il tuo Ambiente API.

  2. Archiviare i seguenti valori nelle variabili da utilizzare nel comando API:

    • subnetId- Per prima cosa, ottieni la tua sottorete e popola la variabile:
    export subnetId=<your_subnet_id>
    • targetId- In secondo luogo, ottenere l'istanza di server virtuale, l'IP riservato o l'application load balancer (ALB) che si trova nella stessa VPC della sottorete:
    export targetId=<your_target_id>

  3. Creare un percorso privato NLB con un ascoltatore, un pool e istanze di server collegate (membri del 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"
     }
 }'

    Output di esempio:

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

    Salva l'ID del programma di bilanciamento del carico da utilizzare nei passi successivi. Ad esempio, salvalo nella variabile lbid.

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

  4. Ottieni dettagli sul programma di bilanciamento del carico del percorso privato:

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

    Lasciare il tempo necessario per il provisioning. Quando è pronto, il programma di bilanciamento del carico viene impostato sullo stato online e active, come mostrato nel seguente output di esempio:

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

Creare un bilanciatore di carico di rete a percorso privato con Terraform

L'esempio seguente crea un bilanciatore di carico di rete Private Path con Terraform:

  1. Creare un NLB con percorso privato:

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

  2. Opzionalmente, creare un pool per il 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. Facoltativamente, si può puntare a un ALB o a un ID di istanza di server virtuale come membro del pool per il 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. Opzionalmente, si può puntare a un IP riservato come membro del pool per il 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
}

Per la documentazione sulle risorse di Terraform, consultare il Registro di Terraform.