Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un bilanciatore del carico esterno basato sul servizio di backend

Autopilota 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 servizi di backend. Prima di leggere questa pagina, assicurati di acquisire familiarità con i seguenti concetti:

Bilanciatore del carico di rete passthrough esterno basato sul servizio di backend

In qualità di amministratore del cluster, puoi creare un servizio LoadBalancer esterno in modo che i clienti esterni al cluster possano inviare pacchetti ai pod del servizio. La il seguente diagramma illustra due bilanciatori del carico di rete passthrough esterni basati su servizio di backend creato per due servizi LoadBalancer esterni (store-v1-lb-svc e store-v2-lb-svc). Entrambi i bilanciatori del carico distribuiscono i pacchetti nei nodi e i nodi instradano pacchetti ai pod di gestione.

Servizi LoadBalancer esterni basati su bilanciatori del carico di rete passthrough esterni basati su servizi di backend regionali

Questa guida mostra come configurare un servizio LoadBalancer esterno denominato store-v1-lb-svc con i seguenti passaggi:

Crea un cluster con il componente aggiuntivo HttpLoadBalancing abilitato.
Crea un servizio che includa l'annotazione cloud.google.com/l4-rbs. Questa annotazione indica a GKE di creare un bilanciatore del carico di rete passthrough esterno basato su servizio di backend che utilizza un servizio di backend regionale.
Verifica che il bilanciatore del carico invii correttamente i pacchetti ai pod del servizio store-v1-lb-svc. Verifica inoltre che GKE abbia creato i componenti del bilanciatore del carico di rete passthrough esterno basato sul servizio di backend:
- Regola di forwarding
- Servizio di backend regionale
- Gruppo di istanze
- Controllo di integrità
- Regole firewall VPC
Elimina il servizio LoadBalancer esterno store-v1-lb-svc.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

Attiva l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, scarica 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.

Configurazione del cluster

Crea un cluster

Utilizza gcloud CLI per creare un nuovo cluster che supporta la creazione di bilanciatori del carico di rete esterni basati sul servizio di backend:

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 GKE canale di rilascio per il cluster.
VERSION: la versione GKE per il cluster, che deve essere 1.24.9 o versioni successive.
COMPUTE_LOCATION: il Regione di Compute Engine nel cluster.

Nel nuovo cluster il componente aggiuntivo HttpLoadBalancing è abilitato per impostazione predefinita. Questo plug-in è necessario affinché il piano di controllo possa creare e gestire bilanciatori del carico di rete passthrough esterni basati su servizi di backend.

Esegui l'upgrade di un cluster esistente

Utilizza gcloud CLI per aggiornare un cluster esistente in modo che supporti la creazione di bilanciatori del carico di rete passthrough esterni basati su servizi di backend.

Esegui l'upgrade del piano di controllo alla versione GKE 1.24.9 o successiva:
```
gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- VERSION: la versione di GKE, che deve essere 1.24.9 o successiva. La versione deve essere un elemento secondario valido nel canale di rilascio del cluster. Per ulteriori informazioni, consulta le Upgrade manuale del piano di controllo.
- COMPUTE_LOCATION: il Località di Compute Engine per il nuovo cluster.

Crea il servizio LoadBalancer esterno

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 2
  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 due pod di gestione 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

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
  externalTrafficPolicy: Cluster
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080
```
Questo servizio LoadBalancer esterno utilizza il valore externalTrafficPolicy predefinito di Cluster. Per informazioni dettagliate su come externalTrafficPolicy definisce il raggruppamento dei nodi, i nodi che superano i controlli di integrità del bilanciatore del carico e l'elaborazione dei pacchetti, consulta Concetti del servizio LoadBalancer.

Se utilizzi un cluster a doppio stack IPv4/IPv6, aggiungi spec.ipFamilyPolicy e ipFamilies per definire in che modo GKE alloca gli indirizzi IP al servizio. Quando utilizzi le specifiche ipFamilyPolicy e ipFamilies, considera le seguenti condizioni:
- Quando crei un bilanciatore del carico di rete passthrough esterno basato su servizi di backend, GKE aggiunge automaticamente l'annotazione cloud.google.com/l4-rbs ai nuovi servizi creati su cluster dual-stack IPv4/IPv6. Tuttavia, se aggiungi l'annotazione cloud.google.com/l4-rbs: "enabled" ai manifest dei servizi esistenti, i servizi LoadBalancer già presenti nel cluster continueranno a utilizzare bilanciatori del carico di rete passthrough esterni basati su pool di destinazione, che sono solo IPv4. Per ulteriori informazioni, consulta la sezione Raggruppamento di nodi.
- GKE può allocare servizi LoadBalancer a stack singolo (solo IPv4 o solo IPv6) o a doppio stack. Un servizio LoadBalancer a doppio stack viene implementato con due regole di forwarding separate per il bilanciatore del carico di rete passthrough esterno: una per gestire il traffico TCP su IPv4 e un'altra per gestire il traffico TCP su IPv6. Per ulteriori informazioni, vedi Servizi.
Applica il manifest al cluster:
```
kubectl apply -f store-v1-lb-svc.yaml
```
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 eroghi un indirizzo IP esterno prima che il bilanciatore del carico sia pronto per gestire la tua 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-

Verifica il servizio LoadBalancer esterno e i suoi componenti

Controlla il servizio LoadBalancer e il relativo insieme di annotazioni che descrivono le risorse Google Cloud:

kubectl describe svc store-v1-lb-svc

L'output è simile al seguente:

Name:                     store-v1-lb-svc
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          service.kubernetes.io/backend-service: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-c086604n-l4-shared-hc-fw
                          service.kubernetes.io/healthcheck: k8s2-c086604n-l4-shared-hc
                          service.kubernetes.io/tcp-forwarding-rule: a683373f85bfe433ba929a50ca8d72e2
Selector:                 app=store
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.44.196.160
IPs:                      10.44.196.160
LoadBalancer Ingress:     35.193.28.231
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  32466/TCP
Endpoints:                10.48.0.5:8080,10.48.2.8:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason                Age                   From                     Message
  ----    ------                ----                  ----                     -------
  Normal  ADD                   2m42s                 loadbalancer-controller  default/store-v1-lb-svc
  Normal  EnsuringLoadBalancer  102s (x2 over 2m42s)  service-controller       Ensuring load balancer
  Normal  Annotations           102s                  loadbalancer-controller  map[cloud.google.com/l4-rbs:enabled kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":"Service","metadata":{"annotations":
{"cloud.google.com/l4-rbs":"enabled"},"name":"store-v1-lb-svc","namespace":"default"}
,"spec":{"externalTrafficPolicy":"Cluster","ports":
[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort":8080}],
"selector":{"app":"store"},"type":"LoadBalancer"}}
] -> map[cloud.google.com/l4-rbs:enabled
kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":
"Service","metadata":{"annotations":{"cloud.google.com/l4-rbs":"enabled"},
"name":"store-v1-lb-svc","namespace":"default"},"spec":{"externalTrafficPolicy"
:"Cluster","ports":[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort"
:8080}],"selector":{"app":"store"},"type":"LoadBalancer"}}
service.kubernetes.io/backend-service:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule-for-hc:k8s2-c086604n-l4-shared-hc-fw
service.kubernetes.io/healthcheck:k8s2-c086604n-l4-shared-hc
service.kubernetes.io/tcp-forwarding-rule:a683373f85bfe433ba929a50ca8d72e2]
Normal  SyncLoadBalancerSuccessful  16s (x3 over 102s)  loadbalancer-controller  Successfully ensured L4 External LoadBalancer resources

Esistono diversi campi che indicano che un servizio di backend il bilanciatore del carico di rete passthrough esterno e le relative risorse Google Cloud sono stati completati creato:

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 abilitato: GKE aggiunge al servizio il seguente elenco di annotazioni di sola lettura del file manifest. 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 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 il controllo di integrità del bilanciatore del carico utilizzato dal servizio di backend.
L'service.kubernetes.io/tcp-forwarding-rule o L'annotazione 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 tramite 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 inoltro, esegui il seguente comando:
```
  gcloud compute forwarding-rules describe FWD_RULE_NAME \
    --region=REGION_NAME
```
Sostituisci quanto segue:
- FWD_RULE_NAME: il nome della regola di forwarding fornito dalle annotazioni service.kubernetes.io/tcp-forwarding-rule o service.kubernetes.io/udp-forwarding-rule di sola lettura. Per controllare queste annotazioni, esegui kubectl describe svc SERVICE_NAME.
- REGION_NAME: la regione Google Cloud in cui si trova il cluster. Per i cluster zonali, la regione contiene la zona utilizzata dal cluster.
Per visualizzare il servizio di backend, esegui questo 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 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 in cui si trova il cluster. Per i cluster di zona, la regione contiene la zona utilizzata dal cluster.
Per vedere le regole del firewall, esegui questi 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 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 (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 e i relativi componenti

Elimina il servizio LoadBalancer esterno store-v1-lb-svc.

kubectl delete service store-v1-lb-svc

GKE elimina le seguenti risorse:

La regola di forwarding del bilanciatore del carico.
Il servizio di backend del bilanciatore del carico.
Il controllo di integrità del bilanciatore del carico.
Le regole firewall VPC necessarie per il bilanciatore del carico e il relativo traffico del controllo di integrità.
Backend dei gruppi di istanze non gestite a livello di zona, solo se GKE non ha bisogno di utilizzarli come backend per altri bilanciatori del carico creati dal cluster.

Passaggi successivi

Per una panoramica generale dei servizi bilanciatori del carico, consulta Servizi LoadBalancer.
Per una descrizione dei parametri dei servizi del bilanciatore del carico, vedi Parametri del servizio LoadBalancer.