Classico: Configurazione del bilanciamento del carico con un NLB 1.0

Versione 1.0: gli NLB possono essere creati solo nei cluster classici e non nei cluster VPC. Per bilanciare il carico nei cluster VPC, vedi Esposizione di applicazioni con i programmi di bilanciamento del carico per VPC.

Esponi una porta e utilizza un indirizzo IP portatile per un NLB (network load balancer) di livello 4 per esporre un'applicazione inserita in un contenitore. Per informazioni sugli NLB versione 1.0, vedi Componenti e architettura di un NLB 1.0.

Configurazione di un NLB 1.0 in un cluster multizona

Prima di iniziare

  • Per creare NLB (network load balancer) pubblici in più zone, almeno una VLAN pubblica deve avere delle sottoreti portatili disponibili in ciascuna zona. Per creare NLB privati in più zone, almeno una VLAN privata deve avere delle sottoreti portatili disponibili in ciascuna zona. Puoi aggiungere sottoreti seguendo la procedura in Configurazione delle sottoreti per i cluster.

  • Abilita una VRF (Virtual Router Function) per il tuo account dell'infrastruttura IBM Cloud. Per abilitare VRF, consultare Abilitazione VRF. Per controllare se una VRF è già abilitata, utilizza il comando ibmcloud account show. Se non puoi o non vuoi abilitare VRF, abilita VLAN spanning. Quando abiliti la VRF o lo spanning della VLAN, l'NLB 1.0 può instradare i pacchetti alle varie sottoreti dell'account.

  • Assicurati di disporre del ruolo di accesso al servizio IAM “ IBM Cloud ”(Writer o Manager ) per lo spazio dei nomi default.

  • Assicurati di avere il numero richiesto di nodi di lavoro:

    • Cluster classici: se limiti il traffico di rete ai nodi di lavoro edge, assicurati che almeno due nodi di lavoro edge siano abilitati in ogni zona in modo che gli NLB vengano distribuiti in modo uniforme.

  • Quando i nodi del cluster vengono ricaricati o quando un aggiornamento del master cluster include una nuova immagine keepalived, l'IP virtuale del programma di bilanciamento del carico viene spostato nell'interfaccia di rete di un nuovo nodo. Quando ciò si verifica, tutte le connessioni di lunga durata al tuo programma di bilanciamento del carico devono essere ristabilite. Considerare l'inclusione della logica dei tentativi nell'applicazione in modo che i tentativi di ristabilire la connessione vengano effettuati rapidamente.

Per configurare un servizio NLB 1.0 in un cluster multizona:

  1. Distribuisci la tua applicazione al cluster. Assicurati di aggiungere un'etichetta nella sezione dei metadati del tuo file di configurazione della distribuzione. Questa etichetta personalizzata identifica tutti i pod su cui viene eseguita la tua applicazione per includerli nel bilanciamento del carico.

  2. Crea un servizio del programma di bilanciamento del carico per l'applicazione che vuoi esporre all'Internet pubblico o a una rete privata.

    1. Crea uno file di configurazione del servizio denominato, ad esempio, myloadbalancer.yaml.
    2. Definisci un servizio del programma di bilanciamento del carico per l'applicazione che vuoi esporre. Puoi specificare una zona, una VLAN e un indirizzo IP.
        apiVersion: v1
    kind: Service
    metadata:
      name: myloadbalancer
      annotations:
        service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type: <public_or_private>
        service.kubernetes.io/ibm-load-balancer-cloud-provider-zone: "<zone>"
        service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan: "<vlan_id>"
    spec:
      type: LoadBalancer
      selector:
        <selector_key>: <selector_value>
      ports:
       - protocol: TCP
         port: 8080
         targetPort: 8080 # Optional. By default, the `targetPort` is set to match the `port` value unless specified otherwise.
      loadBalancerIP: <IP_address>
    ```

    `service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type`
    :   Annotazione per specificare un bilanciatore di carico `private` o `public`. Se non si specifica questa annotazione e i nodi di lavoro sono collegati a VLAN pubbliche, viene creato un servizio " `LoadBalancer` " pubblico. Se i tuoi nodi di lavoro sono connessi solo a VLAN private, viene creato un servizio `LoadBalancer` privato.

    `service.kubernetes.io/ibm-load-balancer-cloud-provider-zone`
    :   Annotazione per specificare la zona in cui viene distribuito il servizio del programma di bilanciamento del carico. Per visualizzare le zone, eseguire il comando ` `ibmcloud ks zone ls``.

    `service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan`
    :   Annotazione per specificare una VLAN in cui viene distribuito il servizio del programma di bilanciamento del carico. Per visualizzare le VLAN, eseguire il comando ` `ibmcloud ks vlan ls --zone <zone>``.

    `selector`
    :   La chiave dell'etichetta (`<selector_key>`) e il valore (`<selector_value>`) che hai utilizzato nella sezione " `spec.template.metadata.labels` " del file YAML di distribuzione della tua app.

    `port`
    :   La porta su cui è in ascolto il servizio.

    `loadBalancerIP`
    :   Facoltativo: per creare un programma di bilanciamento del carico privato o per utilizzare uno specifico indirizzo IP portatile per un programma di bilanciamento del carico pubblico, specifica l'indirizzo IP che vuoi utilizzare. L'indirizzo IP deve essere sulla VLAN e sulla zona che specifichi nelle annotazioni. Se non si specifica un indirizzo IP:
        :   Se il tuo cluster è su una VLAN pubblica, viene utilizzato un indirizzo IP pubblico portatile. Molti cluster sono su una VLAN pubblica.
        :   Se il tuo cluster è solo su una VLAN privata, viene utilizzato un indirizzo IP privato portatile.

    File di configurazione di esempio per creare un servizio NLB privato 1.0 che utilizza un indirizzo IP specificato sulla VLAN privata `2234945` in `dal12`:

    ```yaml {: codeblock}
    apiVersion: v1
    kind: Service
    metadata:
      name: myloadbalancer
      annotations:
        service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type: private
        service.kubernetes.io/ibm-load-balancer-cloud-provider-zone: "dal12"
        service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan: "2234945"
    spec:
      type: LoadBalancer
      selector:
        app: nginx
      ports:
       - protocol: TCP
         port: 8080
         targetPort: 8080 # Optional. By default, the `targetPort` is set to match the `port` value unless specified otherwise.
      loadBalancerIP: 172.21.xxx.xxx
    ```
3. Opzionale: rendere il servizio NLB disponibile solo per un intervallo limitato di indirizzi IP specificando gli indirizzi nel campo " `spec.loadBalancerSourceRanges` ". La funzione " `loadBalancerSourceRanges` " viene implementata da `kube-proxy` nel cluster tramite regole iptables sui nodi di lavoro. Per ulteriori informazioni, consultare la [documentazione relativa a “ Kubernetes](https://kubernetes.io/docs/concepts/services-networking/){: external} ”.

4. Crea il servizio nel tuo cluster.

```sh {: pre}
    kubectl apply -f myloadbalancer.yaml
    ```

  3. Verifica che il servizio NLB sia stato creato correttamente. Perché il servizio venga creato e l'applicazione sia disponibile potrebbero essere richiesti alcuni minuti.

    kubectl describe service myloadbalancer

    Output di esempio:

    NAME:                   myloadbalancer
Namespace:              default
Labels:                 <none>
Selector:               app=liberty
Type:                   LoadBalancer
Zone:                   dal10
IP:                     172.21.xxx.xxx
LoadBalancer Ingress:   169.xx.xxx.xxx
Port:                   <unset> 8080/TCP
NodePort:               <unset> 32040/TCP
Endpoints:              172.30.xxx.xxx:8080
Session Affinity:       None
Events:
    FirstSeen    LastSeen    Count    From            SubObjectPath    Type     Reason                      Message
    ---------    --------    -----    ----            -------------    ----     ------                      -------
    10s            10s            1        {service-controller }      Normal CreatingLoadBalancer    Creating load balancer
    10s            10s            1        {service-controller }        Normal CreatedLoadBalancer    Created load balancer

  4. Se hai creato un NLB pubblico, accedi alla tua applicazione da Internet.

    1. Apri il tuo browser web preferito.
    2. Immetti l'indirizzo IP pubblico portatile dell'NLB e la porta.
        http://169.xx.xxx.xxx:8080
    ```

  5. Ripetere i passaggi da 2 a 4 per aggiungere un'istanza di 1.0 NLB in ciascuna zona.

  6. Se scegli di abilitare la conservazione dell'IP di origine per un NLB 1.0, assicurati che i pod dell'applicazione vengano pianificati sui nodi di lavoro edge aggiungendo l'affinità del nodo edge ai pod dell'applicazione. I pod dell'applicazione devono essere pianificati nei nodi edge per ricevere le richieste in entrata.

  7. Facoltativo: un servizio del programma di bilanciamento del carico rende anche disponibile la tua applicazione sulle NodePort del servizio. Puoi accedere alle NodePort da ogni indirizzo IP pubblico e privato per ogni nodo all'interno del cluster. Per bloccare il traffico alle NodePort mentre stai usando un servizio NLB, vedi Controllo del traffico in entrata nei servizi NLB (network load balancer) o NodePort.

Successivamente, puoi registrare un dominio secondario NLB.

Configurazione di un NLB 1.0 in un cluster a zona singola

Prima di iniziare

  • Devi avere un indirizzo IP pubblico o privato portatile disponibile da assegnare al servizio NLB (network load balancer). Per ulteriori informazioni, vedi Configurazione delle sottoreti per i cluster.

  • Assicurati di disporre del ruolo di accesso al servizio IAM “ IBM Cloud ”(Writer o Manager ) per lo spazio dei nomi default.

  • Quando i nodi del cluster vengono ricaricati o quando un aggiornamento del master cluster include una nuova immagine keepalived, l'IP virtuale del programma di bilanciamento del carico viene spostato nell'interfaccia di rete di un nuovo nodo. Quando ciò si verifica, tutte le connessioni di lunga durata al tuo programma di bilanciamento del carico devono essere ristabilite. Considerare l'inclusione della logica dei tentativi nell'applicazione in modo che i tentativi di ristabilire la connessione vengano effettuati rapidamente.

Per creare un servizio NLB 1.0 in un cluster a zona singola:

  1. Distribuisci la tua applicazione al cluster. Assicurati di aggiungere un'etichetta nella sezione dei metadati del tuo file di configurazione della distribuzione. Questa etichetta personalizzata identifica tutti i pod su cui viene eseguita la tua applicazione per includerli nel bilanciamento del carico.

  2. Crea un servizio del programma di bilanciamento del carico per l'applicazione che vuoi esporre all'Internet pubblico o a una rete privata.

    1. Crea uno file di configurazione del servizio denominato, ad esempio, myloadbalancer.yaml.

    2. Definisci un servizio del programma di bilanciamento del carico per l'applicazione che vuoi esporre.

        apiVersion: v1
    kind: Service
    metadata:
      name: myloadbalancer
      annotations:
        service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type: <public_or_private>
        service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan: "<vlan_id>"
    spec:
      type: LoadBalancer
      selector:
        <selector_key>: <selector_value>
      ports:
       - protocol: TCP
         port: 8080
         targetPort: 8080 # Optional. By default, the `targetPort` is set to match the `port` value unless specified otherwise.
      loadBalancerIP: <IP_address>
    ```
    `service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type`
    :   Annotazione per specificare un bilanciatore di carico `private` o `public`.

    `service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan`
    :   Annotazione per specificare una VLAN in cui viene distribuito il servizio del programma di bilanciamento del carico. Per visualizzare le VLAN, eseguire il comando ` `ibmcloud ks vlan ls --zone <zone>``.

    `selector`
    :   La chiave dell'etichetta (`<selector_key>`) e il valore (`<selector_value>`) che hai utilizzato nella sezione " `spec.template.metadata.labels` " del file YAML di distribuzione della tua app.

    `port`
    :   La porta su cui è in ascolto il servizio.

    `loadBalancerIP`
    :   Facoltativo: per creare un programma di bilanciamento del carico privato o per utilizzare uno specifico indirizzo IP portatile per un programma di bilanciamento del carico pubblico, specifica l'indirizzo IP che vuoi utilizzare. L'indirizzo IP deve essere sulla VLAN che specifichi nelle annotazioni. Se non si specifica un indirizzo IP:
        :   Se il tuo cluster è su una VLAN pubblica, viene utilizzato un indirizzo IP pubblico portatile. Molti cluster sono su una VLAN pubblica.
        :   Se il tuo cluster è solo su una VLAN privata, viene utilizzato un indirizzo IP privato portatile.

    File di configurazione di esempio per creare un servizio NLB 1.0 privato che utilizza un indirizzo IP specificato sulla VLAN privata `2234945`:

    ```yaml {: codeblock}
    apiVersion: v1
    kind: Service
    metadata:
      name: myloadbalancer
      annotations:
        service.kubernetes.io/ibm-load-balancer-cloud-provider-ip-type: private
        service.kubernetes.io/ibm-load-balancer-cloud-provider-vlan: "2234945"
    spec:
      type: LoadBalancer
      selector:
        app: nginx
      ports:
       - protocol: TCP
         port: 8080
         targetPort: 8080 # Optional. By default, the `targetPort` is set to match the `port` value unless specified otherwise.
      loadBalancerIP: 172.21.xxx.xxx
    ```
3. Opzionale: rendere il servizio NLB disponibile solo per un intervallo limitato di indirizzi IP specificando gli indirizzi nel campo " `spec.loadBalancerSourceRanges` ". La funzione " `loadBalancerSourceRanges` " viene implementata da `kube-proxy` nel cluster tramite regole iptables sui nodi di lavoro. Per ulteriori informazioni, consultare la [documentazione relativa a “ Kubernetes](https://kubernetes.io/docs/concepts/services-networking/){: external} ”.

4. Crea il servizio nel tuo cluster.

```sh {: pre}
    kubectl apply -f myloadbalancer.yaml
    ```

  3. Verifica che il servizio NLB sia stato creato correttamente. Perché il servizio venga creato e l'applicazione sia disponibile potrebbero essere richiesti alcuni minuti.

    kubectl describe service myloadbalancer

    Output di esempio:

    NAME:                   myloadbalancer
Namespace:              default
Labels:                 <none>
Selector:               app=liberty
Type:                   LoadBalancer
Location:               dal10
IP:                     172.21.xxx.xxx
LoadBalancer Ingress:   169.xx.xxx.xxx
Port:                   <unset> 8080/TCP
NodePort:               <unset> 32040/TCP
Endpoints:              172.30.xxx.xxx:8080
Session Affinity:       None
Events:
    FirstSeen    LastSeen    Count    From            SubObjectPath    Type     Reason                      Message
    ---------    --------    -----    ----            -------------    ----     ------                      -------
    10s            10s            1        {service-controller }      Normal CreatingLoadBalancer    Creating load balancer
    10s            10s            1        {service-controller }        Normal CreatedLoadBalancer    Created load balancer

    L'indirizzo IP LoadBalancer Ingress è l'indirizzo IP portatile assegnato al tuo servizio NLB.

  4. Se hai creato un NLB pubblico, accedi alla tua applicazione da Internet.

    1. Apri il tuo browser web preferito.
    2. Immetti l'indirizzo IP pubblico portatile dell'NLB e la porta.
        http://169.xx.xxx.xxx:8080
    ```

  5. Se scegli di abilitare la conservazione dell'IP di origine per un NLB 1.0, assicurati che i pod dell'applicazione vengano pianificati sui nodi di lavoro edge aggiungendo l'affinità del nodo edge ai pod dell'applicazione. I pod dell'applicazione devono essere pianificati nei nodi edge per ricevere le richieste in entrata.

  6. Facoltativo: un servizio del programma di bilanciamento del carico rende anche disponibile la tua applicazione sulle NodePort del servizio. Puoi accedere alle NodePort da ogni indirizzo IP pubblico e privato per ogni nodo all'interno del cluster. Per bloccare il traffico alle NodePort mentre stai usando un servizio NLB, vedi Controllo del traffico in entrata nei servizi NLB (network load balancer) o NodePort.

Successivamente, puoi registrare un dominio secondario NLB.

Abilitazione della conservazione dell'IP di origine

Questa funzione è disponibile solo per gli NLB versione 1.0. L'indirizzo IP di origine delle richieste del client viene conservato per impostazione predefinita negli NLB versione 2.0.

Quando una richiesta del client alla tua applicazione viene inviata al tuo cluster, un pod del servizio del programma di bilanciamento del carico riceve la richiesta. Se sullo stesso nodo di lavoro del pod del servizio del programma di bilanciamento del carico non esiste un pod dell'applicazione, l'NLB inoltra la richiesta a un nodo di lavoro diverso. L'indirizzo IP di origine della richiesta viene modificato nell'indirizzo IP pubblico del nodo worker su cui è in esecuzione il pod del servizio di bilanciamento del carico.

Per conservare l'indirizzo IP di origine originale della richiesta del client, è possibile abilitare l'IP di origine per i servizi di bilanciamento del carico. La connessione TCP continua fino ai pod dell'applicazione in modo che l'applicazione possa vedere l'indirizzo IP di origine effettivo dell'initiator. La conservazione dell'IP del client è utile quando, ad esempio, i server delle applicazioni devono applicare le politiche di sicurezza e di controllo dell'accesso.

Una volta abilitato l'IP di origine, i pod del servizio di bilanciamento del carico devono inoltrare le richieste solo ai pod dell'applicazione che sono distribuiti nello stesso nodo di lavoro Di norma, i pod del servizio del programma di bilanciamento del carico vengono distribuiti anche ai nodi di lavoro a cui vengono distribuiti i pod dell'applicazione. Tuttavia, ci sono alcune situazioni in cui i pod del bilanciamento del carico e quelli dell'applicazione potrebbero non essere pianificati sullo stesso nodo di lavoro:

  • Hai nodi edge in cui è presente un taint, in modo che sia possibile distribuire a essi solo pod del servizio di bilanciamento del carico. I pod dell'applicazione non possono essere distribuiti in questi nodi.
  • Il tuo cluster è connesso a più VLAN pubbliche o private e i tuoi pod dell'applicazione possono essere distribuiti ai nodi di lavoro che sono connessi solo ad una VLAN. I pod del servizio di bilanciamento del carico non possono essere distribuiti in tali nodi di lavoro in quanto l'indirizzo IP dell'NLB è connesso a una VLAN diversa da quella dei nodi di lavoro.

Per forzare la tua applicazione alla distribuzione in specifici nodi di lavoro in cui possono essere distribuiti anche i pod del servizio di bilanciamento del carico, devi aggiungere le regole di affinità e le tolleranze alla tua distribuzione dell'applicazione.

Aggiunta delle regole di affinità e delle tolleranze del nodo edge

Quando si imposta contrassegnare i nodi di lavoro come nodi di bordo e anche contaminare i nodi periferici, i pod del servizio di bilanciamento del carico vengono distribuiti solo su quei nodi periferici, mentre i pod delle applicazioni non possono essere distribuiti sui nodi periferici. Quando l'IP di origine è abilitato per il servizio NLB, i pod del bilanciatore di carico sui nodi periferici non possono inoltrare le richieste in entrata ai pod dell'applicazione presenti su altri nodi di lavoro.

Per forzare la distribuzione dei pod dell'app sui nodi periferici, aggiungi una regola di affinità per i nodi periferici e una tolleranza alla distribuzione dell'app.

Esempio di file YAML di distribuzione con affinità e tolleranza del nodo edge:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: with-node-affinity
spec:
  selector:
    matchLabels:
      <label_name>: <label_value>
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: dedicated
                operator: In
                values:
                - edge
      tolerations:
        - key: dedicated
          value: edge
...

Le sezioni “ affinity ” e “ tolerations ” hanno entrambe “ dedicated ” come “ key ” e “ edge ” come “ value ”.

Aggiunta di regole di affinità per più VLAN pubbliche o private

Quando il tuo cluster è connesso a più VLAN pubbliche o private, i tuoi pod dell'applicazione possono essere distribuiti solo nei nodi di lavoro connessi ad una VLAN. Se l'indirizzo IP dell'NLB è connesso a una VLAN diversa da quella di questi nodi di lavoro, i pod del servizio di bilanciamento del carico non vengono distribuiti in questi nodi.

Quando l'IP di origine è abilitato, pianifica i pod dell'applicazione sui nodi di lavoro che si trovano nella stessa VLAN dell'indirizzo IP dell'NLB aggiungendo una regola di affinità alla distribuzione dell'applicazione.

Prima di cominciare:

Accedi al tuo account. Se applicabile, specifica il gruppo di risorse appropriato. Imposta il contesto per il tuo cluster.

  1. Ottieni l'indirizzo IP del servizio NLB. Ricerca l'indirizzo IP nel campo LoadBalancer Ingress.

    kubectl describe service <loadbalancer_service_name>

  2. Richiama l'ID VLAN a cui è connesso il tuo servizio NLB.

    1. Elenca le VLAN pubbliche portatili per il tuo cluster.
        ibmcloud ks cluster get --cluster <cluster_name_or_ID> --show-resources
    ```
    Output di esempio
    ```sh {: screen}
    ...
    Subnet VLANs
    VLAN ID   Subnet CIDR       Public   User-managed
    2234947   10.xxx.xx.xxx/29  false    false
    2234945   169.36.5.xxx/29   true     false
    ```
2. Nell'output, sotto **Subnet VLANs**, ricerca il CIDR di sottorete che corrisponde all'indirizzo IP NLB che hai recuperato in precedenza e prendi nota dell'ID VLAN.

    Ad esempio, se l'indirizzo IP del servizio NLB è `169.36.5.xxx`, la sottorete corrispondente nell'output di esempio del precedente passo è `169.36.5.xxx/29`. L'ID VLAN a cui è connessa la sottorete è `2234945`.

  3. Aggiungi una regola di affinità alla distribuzione dell'app per l'ID VLAN che hai annotato nel passaggio precedente.

    Ad esempio, se hai più VLAN ma desideri che i tuoi pod dell'applicazione vengano distribuiti solo nei nodi di lavoro presenti sulla VLAN pubblica 2234945:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: with-node-affinity
spec:
  selector:
    matchLabels:
      <label_name>: <label_value>
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: publicVLAN
                operator: In
                values:
                - "2234945"
...

    Nel file YAML di esempio, la sezione affinity ha publicVLAN come key e "2234945" come value.

  4. Applica il file di configurazione della distribuzione aggiornato.

    kubectl apply -f with-node-affinity.yaml

  5. Verifica che i pod dell'applicazione vengano distribuiti nei nodi di lavoro connessi alla VLAN designata.

    1. Elenca i pod nel tuo cluster. Sostituisci " <selector> " con l'etichetta che hai utilizzato per l'app.
        kubectl get pods -o wide app=<selector>
    ```
    Output di esempio
    ```sh {: screen}
    NAME                   READY     STATUS              RESTARTS   AGE       IP               NODE
    cf-py-d7b7d94db-vp8pq  1/1       Running             0          10d       172.30.xxx.xxx   10.176.48.78
    ```
2. Nell'output, identifica un pod per la tua applicazione. Prendi nota dell'ID **NODE** del nodo di lavoro in cui il pod è attivo.

    Nell'output di esempio del passo precedente, il pod dell'applicazione `cf-py-d7b7d94db-vp8pq` si trova sul nodo di lavoro `10.176.48.78`.

3. Elenca i dettagli del nodo di lavoro.

```sh {: pre}
    kubectl describe node <worker_node_ID>
    ```
    Output di esempio

    ```sh {: screen}
    NAME:                   10.xxx.xx.xxx
    Role:
    Labels:                 arch=amd64
    beta.kubernetes.io/arch=amd64
    beta.kubernetes.io/os=linux
    failure-domain.beta.kubernetes.io/region=us-south
    failure-domain.beta.kubernetes.io/zone=dal10
    ibm-cloud.kubernetes.io/encrypted-docker-data=true
    kubernetes.io/hostname=10.xxx.xx.xxx
    privateVLAN=2234945
    publicVLAN=2234967
    ...
    ```
4. Nella sezione **Labels** dell'output, verifica che la VLAN pubblica o privata sia la VLAN che hai designato nei passi precedenti.