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, dovresti acquisire familiarità con i seguenti concetti:

Bilanciatore del carico di rete passthrough esterno basato su servizi di backend

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

Servizi esterni del LoadBalancer basati su bilanciatori del carico di rete passthrough esterni basati sul servizio di backend regionale

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 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 a livello di area geografica
- 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à:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installa e initialize gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
Nota: per le installazioni esistenti dell'interfaccia a riga di comando gcloud, assicurati di impostare le proprietà compute/region e compute/zone. Impostando le località predefinite, puoi evitare errori nellgcloud CLI come segue: 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 passthrough esterni basati su 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 canale di rilascio di GKE per il cluster.
VERSION: la versione di GKE per il cluster, che deve essere 1.24.9 o successiva.
COMPUTE_LOCATION: la regione di Compute Engine del cluster.

Il componente aggiuntivo HttpLoadBalancing è abilitato per impostazione predefinita nel nuovo cluster. Questo componente aggiuntivo è necessario per consentire al piano di controllo di creare e gestire bilanciatori del carico di rete passthrough esterni basati su servizio di backend.

Esegui l'upgrade di un cluster esistente

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

Esegui l'upgrade del piano di controllo a GKE versione 1.24.9 o successive:
```
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 una versione secondaria valida nel canale di rilascio del cluster. Per saperne di più, consulta la pagina Eseguire l'upgrade manuale del piano di controllo.
- COMPUTE_LOCATION: la località di Compute Engine per il nuovo cluster.

Crea il servizio LoadBalancer esterno

Salva il deployment di esempio seguente 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 esistano 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 predefinito externalTrafficPolicy di Cluster. Per maggiori dettagli 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 i concetti del servizio LoadBalancer.

Se utilizzi un cluster IPv4/IPv6 a doppio stack, aggiungi spec.ipFamilyPolicy e ipFamilies per definire la modalità di allocazione degli indirizzi IP da parte di GKE 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 servizio 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à esistenti nel cluster continueranno a utilizzare bilanciatori del carico di rete passthrough esterni basati sul pool di destinazione, che sono solo IPv4. Per ulteriori informazioni, consulta la sezione Raggruppamento dei nodi.
- GKE può allocare servizi LoadBalancer a stack singolo (solo IPv4 o solo IPv6) o a doppio stack. Un servizio LoadBalancer a doppio stack è implementato con due regole di forwarding del bilanciatore del carico di rete passthrough esterno separate: una per la gestione del traffico TCP su IPv4 e un'altra per la gestione del traffico TCP su IPv6. Per maggiori 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 valore EXTERNAL_IP al bilanciatore del carico di rete passthrough esterno.

Nota: GKE potrebbe impiegare qualche minuto per allocare un indirizzo IP esterno prima che il bilanciatore del carico sia pronto per gestire l'applicazione.

Verifica 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-

Verificare il servizio LoadBalancer esterno e i relativi componenti

Controlla il servizio LoadBalancer e il set di annotazioni che descrivono le relative 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 bilanciatore del carico di rete passthrough esterno basato su servizio di backend e le relative risorse Google Cloud sono stati creati correttamente:

Campo Events. Questo campo è vuoto una volta creati correttamente il servizio LoadBalancer e le relative risorse. Se si è verificato un errore, viene elencato qui.
Elenco di Annotations abilitato: GKE aggiunge il seguente elenco di annotazioni di sola lettura al manifest di servizio. Ogni annotazione il cui nome inizia con service.kubernetes.io/ viene utilizzata per indicare il nome di una risorsa Google Cloud creata come parte di o per supportare il 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 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 verso i 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 del firewall siano state create per il servizio LoadBalancer esterno:

Per vedere la regola di forwarding, esegui questo 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 contenente il cluster. Per i cluster di zona, la regione contiene la zona utilizzata dal cluster.
Per vedere 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 questo comando:
```
gcloud compute health-checks describe HEALTH_CHECK_NAME \
  --region=REGION_NAME
```
Sostituisci quanto segue:
- HEALTH_CHECK_NAME: 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 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 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 per il controllo di integrità.
I backend dei gruppi di istanze non gestite a livello di zona vengono eseguiti 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 di bilanciamento del carico, vedi Servizi LoadBalancer.
Per una descrizione dei parametri dei servizi del bilanciatore del carico, vedi Parametri del servizio LoadBalancer.