Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un bilanciatore del carico esterno basato su servizio di backend

Autopilot Standard

Questa pagina mostra come eseguire il deployment di un servizio LoadBalancer esterno che crea un bilanciatore del carico di rete passthrough esterno basato su servizio di backend. Prima di leggere questa pagina, assicurati di conoscere quanto segue:

Per saperne di più sui bilanciatori del carico di rete passthrough esterni in generale, consulta Bilanciatore del carico di rete passthrough esterno basato su servizio di backend.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

Attiva l'API Google Kubernetes Engine.

Attiva l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Requisiti

Per creare un servizio LoadBalancer esterno, il tuo cluster GKE deve utilizzare la versione 1.25.5 o successive. Per utilizzare il bilanciamento del carico ponderato, il cluster deve utilizzare la versione 1.31.0-gke.1506000 o successive.
Il componente aggiuntivo HttpLoadBalancing deve essere abilitato nel cluster. Questo componente aggiuntivo è attivo per impostazione predefinita. Consente al cluster di gestire i bilanciatori del carico che utilizzano i servizi di backend.

Scegli un cluster

Puoi creare un nuovo cluster o scegliere un cluster esistente che soddisfi i requisiti.

Crea un nuovo cluster

Autopilot

Per creare un nuovo cluster Autopilot:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Sostituisci quanto segue:

CLUSTER_NAME: il nome del nuovo cluster.
RELEASE_CHANNEL: il nome del canale di rilascio GKE per il cluster.
VERSION: la versione GKE per il cluster.
COMPUTE_LOCATION: la regione Compute Engine del cluster.

Standard

Per creare un nuovo cluster standard:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Sostituisci quanto segue:

CLUSTER_NAME: il nome del nuovo cluster.
RELEASE_CHANNEL: il nome del canale di rilascio GKE per il cluster.
VERSION: la versione GKE per il cluster.
COMPUTE_LOCATION: la regione Compute Engine del cluster.

Eseguire l'upgrade di un cluster esistente

Utilizza gcloud CLI per aggiornare un cluster esistente:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Sostituisci quanto segue:

CLUSTER_NAME: il nome del cluster esistente.
VERSION: la versione specifica di GKE a cui vuoi eseguire l'upgrade del cluster. Per ulteriori informazioni, consulta Eseguire manualmente l'upgrade del piano di controllo.
COMPUTE_LOCATION: la regione Compute Engine del cluster.

Esegui il deployment di un carico di lavoro di esempio

Esegui il deployment del seguente carico di lavoro di esempio che fornisce i pod di servizio per il servizio LoadBalancer esterno.

Salva il seguente deployment di esempio come store-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 20
  selector:
    matchLabels:
      app: store
  template:
    metadata:
      labels:
        app: store
    spec:
      containers:
      - image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: Always
        name: echoserver
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP

Applica il manifest al cluster:
```
kubectl apply -f store-deployment.yaml
```

Verifica che siano presenti 20 pod di servizio per il deployment:

kubectl get pods

L'output è simile al seguente:

NAME                     READY   STATUS    RESTARTS   AGE
store-cdb9bb4d6-s25vw      1/1     Running   0          10s
store-cdb9bb4d6-vck6s      1/1     Running   0          10s
....

Crea il servizio LoadBalancer esterno

Esponi il carico di lavoro di esempio creando un servizio LoadBalancer esterno.

Salva il seguente manifest del servizio come store-v1-lb-svc.yaml:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
spec:
  type: LoadBalancer
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Applica il manifest al cluster:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Tieni presente quanto segue in merito a questo manifest di esempio:

Il file manifest del servizio deve includere l'annotazione cloud.google.com/l4-rbs: "enabled" al momento della prima applicazione del manifest al cluster. In questo modo, GKE viene incaricato di creare un bilanciatore del carico di rete passthrough esterno basato su servizio di backend. I bilanciatori del carico di rete passthrough esterni basati su servizi di backend sono obbligatori per supportare funzionalità come IPv6 e il bilanciamento del carico ponderato.
Se aggiungi l'annotazione cloud.google.com/l4-rbs: "enabled" al manifest di un servizio LoadBalancer esterno esistente (ovvero dopo la creazione del bilanciatore del carico), GKE ignora l'annotazione. I servizi LoadBalancer esterni creati senza questa annotazione nei relativi manifest utilizzano bilanciatori del carico di rete passthrough esterni basati su pool di destinazione. L'utilizzo di bilanciatori del carico di rete passthrough esterni basati su pool di destinazione è sconsigliato.

Attivare il bilanciamento del carico ponderato

Per distribuire le nuove connessioni proporzionalmente ai nodi in base al numero di pod in esecuzione, pronti e non finalizzanti presenti su ciascun nodo, attiva il bilanciamento del carico ponderato aggiungendo l'annotazione networking.gke.io/weighted-load-balancing: "pods-per-node" al manifest del servizio.

Aggiungi l'annotazione networking.gke.io/weighted-load-balancing: "pods-per-node" al manifest del servizio store-v1-lb-svc.yaml e assicurati di impostare anche externalTrafficPolicy: Local in modo che risulti come segue:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
    networking.gke.io/weighted-load-balancing: "pods-per-node"
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Applica il manifest al cluster:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Tieni presente quanto segue in merito a questo esempio di bilanciamento del carico ponderato:

Il manifest del servizio utilizza externalTrafficPolicy: Local. Se non devi abilitare il bilanciamento del carico ponderato, puoi anche utilizzare externalTrafficPolicy: Cluster. Per informazioni dettagliate su come externalTrafficPolicy definisce il raggruppamento dei nodi, su quali nodi superano i controlli di integrità del bilanciatore del carico e su come vengono elaborati i pacchetti, consulta Concetti di servizio LoadBalancer.
Se attivi il bilanciamento del carico ponderato, GKE non impedisce di utilizzare externalTrafficPolicy: Cluster, ma externalTrafficPolicy: Cluster disattiva effettivamente il bilanciamento del carico ponderato perché il pacchetto potrebbe essere instradato, dopo il bilanciatore del carico, a un altro nodo.

Puoi anche attivare il bilanciamento del carico ponderato su un servizio LoadBalancer esterno esistente utilizzando kubectl edit svc service-name. Il comando kubectl edit apre il file manifest del servizio del bilanciatore del carico esistente nel tuo editor di testo configurato, dove puoi modificare il file manifest e salvare le modifiche. Quando modifichi un servizio LoadBalancer esterno esistente,tieni presente quanto segue:

Il servizio LoadBalancer esterno esistente deve aver generato la creazione di bilanciatori del carico di rete passthrough esterni basati su servizio di backend. Ciò significa che il servizio LoadBalancer esterno esistente deve aver incluso l'annotazione cloud.google.com/l4-rbs: "enabled" quando il manifest è stato applicato per la prima volta al cluster.

L'aggiunta dell'annotazione networking.gke.io/weighted-load-balancing: "pods-per-node" a un servizio LoadBalancer esterno esistente che utilizza un bilanciatore del carico di rete passthrough esterno basato su pool di destinazione non ha alcun effetto.
Quando aggiorni il manifest del servizio LoadBalancer esterno esistente, assicurati di impostare externalTrafficPolicy: Local. L'utilizzo di externalTrafficPolicy: Cluster disattiva efficacemente il bilanciamento del carico ponderato perché il pacchetto potrebbe essere instradato, dopo il bilanciatore del carico, a un altro nodo.

Disattivare il bilanciamento del carico ponderato

Per distribuire le nuove connessioni ai nodi indipendentemente dal numero di pod di servizio presenti su ciascun nodo, disattiva il bilanciamento del carico ponderato rimuovendo l'annotazione networking.gke.io/weighted-load-balancing: "pods-per-node" dal manifest del servizio.

Verifica il servizio LoadBalancer esterno e i relativi componenti

Verifica che il servizio sia in esecuzione:
```
kubectl get svc store-v1-lb-svc
```
L'output è simile al seguente:
```
NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
```
GKE ha assegnato un EXTERNAL_IP per il bilanciatore del carico di rete passthrough esterno.

Nota: potrebbero essere necessari alcuni minuti prima che GKE alloca un indirizzo IP esterno prima che il bilanciatore del carico sia pronto per gestire l'applicazione.

Testa la connessione al bilanciatore del carico:

curl EXTERNAL_IP:PORT

Sostituisci quanto segue:

EXTERNAL_IP: l'indirizzo IP allocato per il bilanciatore del carico di rete passthrough esterno.
PORT: il numero di porta allocato per il bilanciatore del carico di rete passthrough esterno.

L'output è simile al seguente:

Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd

Pod Information:
  -no pod information available-

Server values:
  server_version=nginx: 1.13.3 - lua: 10008

Request Information:
  client_address=10.128.0.50
  method=GET
  real path=/
  query=
  request_version=1.1
  request_scheme=http
  request_uri=EXTERNAL_IP

Request Headers:
  accept=*/*
  host=EXTERNAL_IP
  user-agent=curl/7.81.0

Request Body:
  -no body in request-

Controlla il servizio LoadBalancer e il relativo insieme di annotazioni che descrivono le sue risorse Google Cloud:
```
kubectl describe svc store-v1-lb-svc
```
L'output è simile al seguente:
```
Name:                     my-service-external
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                          service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                          service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
Selector:                 app=my-app
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.18.102.23
IPs:                      10.18.102.23
LoadBalancer Ingress:     35.184.160.229
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  31864/TCP
Endpoints:                10.20.1.28:8080,10.20.1.29:8080
Session Affinity:         None
External Traffic Policy:  Local
HealthCheck NodePort:     30394

Events:
  Type    Reason                Age                    From                     Message
  ----    ------                ----                   ----                     -------
  Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
```
Esistono diversi campi che indicano che è stato creato correttamente un bilanciatore del carico di rete passthrough esterno basato su un servizio di backend e le relative risorse Google Cloud:
- Campo Events. Questo campo è vuoto quando il servizio LoadBalancer e le relative risorse sono stati creati correttamente. Se si è verificato un errore, viene elencato qui.
- Elenco di Annotations abilitati: GKE aggiunge il seguente elenco di annotazione di sola lettura al file manifest del servizio. Ogni annotazione il cui nome inizia con service.kubernetes.io/ viene utilizzata per indicare il nome di una risorsa Google Cloud creata nell'ambito o a supporto del bilanciatore del carico.
  - L'annotazione networking.gke.io/weighted-load-balancing: pods-per-node indica che è stato applicato il bilanciamento del carico ponderato e che il bilanciatore del carico distribuisce il traffico ai pod di backend in base al numero di pod in esecuzione su ciascun nodo.
  - L'annotazione service.kubernetes.io/backend-service indica il nome del servizio di backend del bilanciatore del carico.
  - L'annotazione service.kubernetes.io/healthcheck indica il nome del controllo di integrità del bilanciatore del carico utilizzato dal servizio di backend.
  - L'annotazione service.kubernetes.io/tcp-forwarding-rule o service.kubernetes.io/udp-forwarding-rule indica il nome della regola di forwarding del bilanciatore del carico.
  - L'annotazione service.kubernetes.io/firewall-rule indica il nome della regola firewall creata per consentire il traffico ai nodi del cluster. Gli intervalli di origine per questa regola firewall sono personalizzabili utilizzando spec.loadBalancerSourceRanges[]. Per ulteriori dettagli sulle regole firewall per i servizi LoadBalancer, consulta Regole firewall e lista consentita di indirizzi IP di origine.
  - L'annotazione service.kubernetes.io/firewall-rule-for-hc indica il nome della regola firewall richiesta per i controlli di integrità del bilanciatore del carico.
Verifica che le risorse del bilanciatore del carico e le regole firewall siano state create per il servizio LoadBalancer esterno:
- Per visualizzare la regola di forwarding, esegui il seguente comando:
```
  gcloud compute forwarding-rules describe FWD_RULE_NAME \
    --region=REGION_NAME
```
  Sostituisci quanto segue:
  - FWD_RULE_NAME: il nome regola di forwarding fornito dalle annotazioni di sola lettura service.kubernetes.io/tcp-forwarding-rule o service.kubernetes.io/udp-forwarding-rule. Per controllare queste annotazioni, esegui kubectl describe svc SERVICE_NAME.
  - REGION_NAME: la regione Google Cloud contenente il cluster. Per i cluster di zona, la regione contiene la zona utilizzata dal cluster.
- Per visualizzare il servizio di backend, esegui il seguente comando:
```
gcloud compute backend-services describe BACKEND_SERVICE_NAME \
  --region=REGION_NAME
```
  Sostituisci quanto segue:
  - BACKEND_SERVICE_NAME: il nome del servizio di backend fornito dall'annotazione di sola lettura service.kubernetes.io/backend-service. Per controllare questa annotazione di sola lettura, esegui kubectl describe svc SERVICE_NAME.
  - REGION_NAME: la regione Google Cloud contenente il cluster. Per i cluster a livello di zona, la regione contiene la zona utilizzata dal cluster.
- Per visualizzare il controllo di integrità del bilanciatore del carico, esegui il seguente comando:
```
gcloud compute health-checks describe HEALTH_CHECK_NAME \
  --region=REGION_NAME
```
  Sostituisci quanto segue:
  - HEALTH_CHECK_NAME: il nome del controllo di integrità del bilanciatore del carico. Il nome del controllo di integrità è fornito dall'annotazione di sola lettura service.kubernetes.io/healthcheck. Per controllare questa annotazione di sola lettura, esegui kubectl describe svc SERVICE_NAME.
  - REGION_NAME: la regione Google Cloud contenente il cluster. Per i cluster a livello di zona, la regione contiene la zona utilizzata dal cluster.
- Per visualizzare le regole del firewall, esegui i seguenti comandi:
```
gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
```
  Sostituisci quanto segue:
  - FIREWALL_RULE_NAME: il nome della regola del firewall che consente il traffico al bilanciatore del carico. Il nome di questa regola del firewall è fornito dall'annotazione di sola lettura service.kubernetes.io/firewall-rule. Per controllare questa annotazione di sola lettura, esegui kubectl describe svc SERVICE_NAME.
  - HEALTH_CHECK_FIREWALL_RULE_NAME: il nome della regola firewall che consente i controlli di integrità dei backend del bilanciatore del carico (i nodi del cluster). Il nome di questa regola firewall è fornito dall'annotazione di sola lettura service.kubernetes.io/firewall-rule-for-hc. Per controllare questa annotazione di sola lettura, esegui kubectl describe svc SERVICE_NAME.

Elimina il servizio LoadBalancer esterno

Per eliminare il servizio LoadBalancer esterno store-v1-lb-svc di esempio, utilizza questo comando:

kubectl delete service store-v1-lb-svc

GKE rimuove automaticamente tutte le risorse del bilanciatore del carico che ha creato per il servizio LoadBalancer esterno.

Risolvi i problemi relativi al servizio LoadBalancer esterno

Se non imposti externalTrafficPolicy: Local, potresti ricevere un evento di avviso quando descrivi il servizio utilizzando il seguente comando:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Per attivare efficacemente il bilanciamento del carico ponderato, devi impostare externalTrafficPolicy: Local.

Passaggi successivi

Per una panoramica generale dei servizi bilanciatori del carico, consulta Servizi LoadBalancer.
Per una descrizione dei parametri dei servizi di bilanciamento del carico, consulta Parametri del servizio LoadBalancer.
Risolvi i problemi di bilanciamento del carico in GKE.