Prima di iniziare

Prima di proseguire, assicurati di soddisfare tutti i prerequisiti indicati nella guida " 2.0 " di NLB.

• Per creare NLB 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.

• 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 NLB 2.0 in un cluster multizona:

1. Distribuisci la tua applicazione al cluster. Assicurati di aggiungere un'etichetta alla tua distribuzione nella sezione dei metadati del tuo file di configurazione. 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>"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-enable-features: "ipvs"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-ipvs-scheduler: "<algorithm>"
       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>
         externalTrafficPolicy: Local
       ```
       `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-zone`
       :   Annotazione per specificare la zona in cui viene distribuito il servizio del programma di bilanciamento del carico. Per visualizzare le zone, esegui il comando ` `ibmcloud oc 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 oc vlan ls --zone ZONE``.
   
       `service.kubernetes.io/ibm-load-balancer-cloud-provider-enable-features: "ipvs"`
       :   Annotazione per specificare un programma di bilanciamento del carico versione 2.0.
   
       `service.kubernetes.io/ibm-load-balancer-cloud-provider-ipvs-scheduler`
       :   Facoltativo: annotazione per specificare l'algoritmo di pianificazione. I valori ammessi sono `"rr"` per il metodo round-robin (impostazione predefinita) oppure `"sh"` per il metodo Source Hashing. Per ulteriori informazioni, vedi [2.0: Algoritmi di pianificazione](#scheduling).
   
       `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 NLB privato o utilizzare un indirizzo IP portatile specifico per un NLB pubblico, specifica l'indirizzo IP che vuoi utilizzare. L'indirizzo IP deve essere nella zona e nella 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.
   
       `externalTrafficPolicy: Local`
       :   Imposta su `Local`.
   
   
       File di configurazione di esempio per creare un servizio NLB 2.0 in `dal12` che utilizza l'algoritmo di distribuzione round-robin:
   
       ```yaml {: codeblock}
       apiVersion: v1
       kind: Service
       metadata:
         name: myloadbalancer
         annotations:
           service.kubernetes.io/ibm-load-balancer-cloud-provider-zone: "dal12"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-enable-features: "ipvs"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-ipvs-scheduler: "rr"
       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.
         externalTrafficPolicy: Local
       ```
   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}
       oc apply -f myloadbalancer.yaml
       ```
   

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

   oc 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
   

   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. Per garantire un'elevata disponibilità, ripetere i passaggi da 2 a 4 per aggiungere un' 2.0 e NLB in ciascuna zona in cui sono presenti istanze dell'applicazione.

6. Facoltativo: un servizio NLB rende anche disponibile la tua applicazione anche 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.

Prima di iniziare

Prima di proseguire, assicurati di soddisfare tutti i prerequisiti indicati nella guida " 2.0 " di NLB.

• Devi avere un indirizzo IP pubblico o privato portatile disponibile da assegnare al servizio NLB. 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 2.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 2.0 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>"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-enable-features: "ipvs"
           service.kubernetes.io/ibm-load-balancer-cloud-provider-ipvs-scheduler: "<algorithm>"
       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>
         externalTrafficPolicy: Local
       ```
       `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`
       :   Facoltativo: 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 oc vlan ls --zone ZONE``.
   
       `service.kubernetes.io/ibm-load-balancer-cloud-provider-enable-features: "ipvs"`
       :   Annotazione per specificare un programma di bilanciamento del carico 2.0.
   
       `service.kubernetes.io/ibm-load-balancer-cloud-provider-ipvs-scheduler`
       :   Facoltativo: annotazione per specificare un algoritmo di pianificazione. I valori ammessi sono `"rr"` per il metodo round-robin (impostazione predefinita) oppure `"sh"` per il metodo Source Hashing. Per ulteriori informazioni, vedi [2.0: Algoritmi di pianificazione](#scheduling).
   
   
       `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 NLB privato o utilizzare un indirizzo IP portatile specifico per un NLB 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.
   
   
       `externalTrafficPolicy: Local`
       :   Imposta su `Local`.
   
   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}
       oc 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.

   oc 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. Facoltativo: un servizio NLB rende anche disponibile la tua applicazione anche 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.

Algoritmi di pianificazione supportati

Round Robin (rr)

L'NLB scorre attraverso l'elenco di pod dell'applicazione quando instradano le connessioni ai nodi di lavoro, trattando ogni pod dell'applicazione allo stesso modo. round-robin è l'algoritmo di pianificazione predefinito per gli NLB versione 2.0.

Source Hashing (sh)

L'NLB genera una chiave di hash in base all'indirizzo IP di origine del pacchetto di richieste del client. Quindi, l'NLB cerca la chiave di hash in una tabella hash assegnata staticamente e inoltra la richiesta al pod dell'applicazione che gestisce gli hash di tale intervallo. Questo algoritmo garantisce che le richieste provenienti da un determinato client siano sempre indirizzate allo stesso pod dell'applicazione. Kubernetes utilizza regole iptables che fanno sì che le richieste vengano inviate a un pod casuale sul worker. Per utilizzare questo algoritmo di pianificazione, devi assicurarti che non venga distribuito più di un pod della tua applicazione per ciascun nodo di lavoro. Ad esempio, se ogni pod ha l'etichetta " run=<app_name>", aggiungi la seguente regola di anti-affinità alla sezione " spec " della distribuzione della tua app:

spec:
  affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 100
      podAffinityTerm:
        labelSelector:
          matchExpressions:
          - key: run
            operator: In
            values:
            - <APP_NAME>
        topologyKey: kubernetes.io/hostname

Algoritmi di pianificazione non supportati

Destination Hashing (dh)

La destinazione del pacchetto, che è composta dall'indirizzo IP dell'NLB e dalla porta, viene utilizzata per determinare quale nodo di lavoro gestisce la richiesta in entrata. Tuttavia, l'indirizzo IP e la porta degli NLB in Red Hat OpenShift on IBM Cloud non cambiano. All'NLB viene imposto di mantenere la richiesta nello stesso nodo di lavoro in cui si trova, quindi i pod dell'applicazione di un unico nodo di lavoro gestiscono tutte le richieste in entrata.

Algoritmi di conteggio dinamico delle connessioni

I seguenti algoritmi dipendono dal conteggio dinamico delle connessioni tra client e NLB. Tuttavia, poiché il DSR (direct service return) impedisce ai pod NLB 2.0 di trovarsi nel percorso del pacchetto restituito, gli NLB non tracciano le connessioni stabilite.

• Least Connection (lc)
• Metodo "Least Connection" basato sulla località (lblc)
• Metodo "Least Connection" basato sulla località con replica (lblcr)
• Never Queue (nq)
• Ritardo previsto minimo (seq)

Algoritmi di pod ponderati

I seguenti algoritmi dipendono dai pod dell'applicazione ponderati. Tuttavia, in Red Hat OpenShift on IBM Cloud, a tutti i pod dell'applicazione viene assegnato lo stesso peso per il bilanciamento del carico.

• Metodo dei minimi ponderati (wlc)
• Round - robin ponderato (wrr)