Creare un bilanciatore del carico interno tra reti VPC

Questa pagina spiega come creare un bilanciatore del carico di rete passthrough interno su Google Kubernetes Engine (GKE) nelle reti VPC.

Prima di leggere questa pagina, assicurati di avere familiarità con i seguenti concetti:

• Servizio LoadBalancer.
• Parametri del servizio LoadBalancer.
• Private Service Connect.

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à, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Crea un bilanciatore del carico interno con Private Service Connect

In qualità di producer di servizi, puoi utilizzare i collegamenti di servizio per rendere i tuoi servizi disponibili ai consumer di servizi in altre reti VPC utilizzando Private Service Connect. Puoi creare, gestire ed eliminare i collegamenti di servizio utilizzando una risorsa personalizzata ServiceAttachment.

Requisiti e limitazioni

• Si applicano le limitazioni per Private Service Connect.
• Puoi creare un collegamento del servizio nelle versioni di GKE 1.21.4-gke.300 e successive.
• Non puoi utilizzare la stessa subnet in più configurazioni di collegamento del servizio.
• Devi creare un servizio GKE che utilizzi un bilanciatore del carico di rete passthrough interno.
• Non puoi specificare una subnet in un progetto diverso (VPC condiviso) per le versioni di GKE precedenti alla 1.22.4-gke.100. Per il VPC condiviso, assicurati che tutti i requisiti per il VPC condiviso siano soddisfatti.
• Dopo aver creato un collegamento del servizio, non puoi aggiornare il bilanciatore del carico interno. Per modificare le configurazioni del bilanciatore del carico, devi eliminare e ricreare il collegamento del servizio.

Crea un ServiceAttachment

1. Crea una subnet.

   Devi creare una nuova subnet per ogni ServiceAttachment.

   gcloud beta compute networks subnets create SUBNET_NAME \
       --project PROJECT_ID \
       --network NETWORK_NAME \
       --region REGION \
       --range SUBNET_RANGE \
       --purpose PRIVATE_SERVICE_CONNECT
   

   Sostituisci quanto segue:

   • SUBNET_NAME: il nome della nuova subnet. Nelle versioni di GKE 1.22.4-gke.100 e successive, puoi specificare una subnet in un progetto diverso utilizzando l'URL della risorsa completo per questo campo. Puoi ottenere l'URL della risorsa completo utilizzando il comando gcloud compute networks subnets describe.
   • PROJECT_ID: l'ID del tuo progetto Trusted Cloud.
   • NETWORK_NAME: il nome della rete VPC per la subnet.
   • REGION: la regione della nuova subnet. Devi utilizzare la stessa regione del servizio che crei.
   • SUBNET_RANGE: l'intervallo di indirizzi IP da utilizzare per la subnet.

2. Esegui il deployment di un carico di lavoro.

   Il seguente manifest descrive un deployment che esegue un'immagine container di esempio dell'applicazione web. Salva il manifest come my-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: psc-ilb
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: psc-ilb
     template:
       metadata:
         labels:
           app: psc-ilb
       spec:
         containers:
         - name: whereami
           image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1
           ports:
             - name: http
               containerPort: 8080
           readinessProbe:
             httpGet:
               path: /healthz
               port: 8080
               scheme: HTTP
             initialDelaySeconds: 5
             timeoutSeconds: 1
   

3. Applica il manifest al cluster:

   kubectl apply -f my-deployment.yaml
   

4. Crea un servizio. Il seguente manifest descrive un servizio che crea un bilanciatore del carico di rete passthrough interno sulla porta TCP 8080. Salva il manifest come my-service.yaml:

    apiVersion: v1
    kind: Service
    metadata:
      name: SERVICE_NAME
      annotations:
        networking.gke.io/load-balancer-type: "Internal"
    spec:
      type: LoadBalancer
      selector:
        app: psc-ilb
      ports:
      - port: 80
        targetPort: 8080
        protocol: TCP
   

   Sostituisci quanto segue:

   • SERVICE_NAME: il nome del nuovo servizio.

5. Applica il manifest al cluster:

   kubectl apply -f my-service.yaml
   

6. Crea ServiceAttachment.

   Il seguente manifest descrive un ServiceAttachment che espone il servizio che hai creato ai consumatori di servizi. Salva il file manifest come my-psc.yaml:

   apiVersion: networking.gke.io/v1
   kind: ServiceAttachment
   metadata:
    name: SERVICE_ATTACHMENT_NAME
    namespace: default
   spec:
    connectionPreference: ACCEPT_AUTOMATIC
    natSubnets:
    - SUBNET_NAME
    proxyProtocol: false
    resourceRef:
      kind: Service
      name: SERVICE_NAME
   

   Sostituisci quanto segue:

   • SERVICE_ATTACHMENT_NAME: il nome del nuovo allegato di servizio.
   • SUBNET_NAME: il nome della nuova subnet. Nelle versioni di GKE 1.22.4-gke.100 e successive, puoi specificare una subnet in un progetto diverso utilizzando l'URL della risorsa completo per questo campo. Puoi ottenere l'URL della risorsa completo utilizzando il comando gcloud compute networks subnets describe. Per una configurazione VPC condiviso, utilizza il seguente formato: projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNET_NAME.

   Per ulteriori informazioni sui campi del manifest, consulta i campi del collegamento del servizio.

7. Applica il manifest al cluster:

   kubectl apply -f my-psc.yaml
   

8. Verifica che il controller Private Service Connect abbia creato il collegamento del servizio:

   gcloud beta compute service-attachments list
   

   L'output mostra un collegamento al servizio con un nome generato automaticamente:

   NAME        REGION       PRODUCER_FORWARDING_RULE          CONNECTION_PREFERENCE
   k8s1-sa-... REGION_NAME  a3fea439c870148bdba5e59c9ea9451a  ACCEPT_AUTOMATIC
   

Visualizza un ServiceAttachment

Puoi visualizzare i dettagli di un ServiceAttachment utilizzando il seguente comando:

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

L'output è simile al seguente:

Name:        <sa-name>
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1beta1
Kind:         ServiceAttachment
Metadata:
  ...
Status:
  Forwarding Rule URL:      https://www.googleapis.com/compute/beta/projects/<project>/regions/<region>/forwardingRules/<fr-name>
  Last Modified Timestamp:  2021-07-08T01:32:39Z
  Service Attachment URL:   https://www.googleapis.com/compute/beta/projects/<projects>/regions/<region>/serviceAttachments/<gce-service-attachment-name>
Events:                     <none>

Consumare un ServiceAttachment

Per utilizzare il servizio da un altro progetto:

1. Recupera l'URL di ServiceAttachment:

   kubectl get serviceattachment SERVICE_ATTACHMENT_NAME -o=jsonpath="{.status.serviceAttachmentURL}"
   

   L'output è simile al seguente:

     serviceAttachmentURL: https://www.googleapis.com/compute/alpha/projects/<project>/region/<region>/serviceAttachments/k8s1-...my-sa
   

2. Crea un endpoint Private Service Connect utilizzando l'URL di ServiceAttachment.

3. Verifica di poterti connettere al servizio che hai deployment nel progetto producer utilizzando un comando curl da una VM nel progetto consumer:

   curl PSC_IP_ADDRESS
   

   Sostituisci PSC_IP_ADDRESS con l'indirizzo IP della regola di forwarding nel progetto consumer.

   L'output è simile al seguente:

   {
     "cluster_name":"cluster",
     "host_header":"10.128.15.200",
     "node_name":"gke-psc-default-pool-be9b6e0e-dvxg.c.gke_project.internal",
     "pod_name":"foo-7bf648dcfd-l5jf8",
     "pod_name_emoji":"👚",
     "project_id":"gke_project",
     "timestamp":"2021-06-29T21:32:03",
     "zone":"ZONE_NAME"
   }
   

Aggiornare un ServiceAttachment

Per aggiornare un ServiceAttachment, segui questi passaggi:

1. Modifica il manifest ServiceAttachment in my-psc.yaml:

   apiVersion: networking.gke.io/v1
   kind: ServiceAttachment
   metadata:
     name: my-sa
     namespace: default
   spec:
     connectionPreference: ACCEPT_AUTOMATIC
     natSubnets:
     - my-nat-subnet
     proxyProtocol: false
     resourceRef:
       kind: Service
       name: ilb-service
   

2. Applica il manifest al cluster:

   kubectl apply -f my-psc.yaml
   

Eliminare un ServiceAttachment

Non puoi eliminare un bilanciatore del carico di rete passthrough interno connesso a un collegamento del servizio. Devi eliminare il collegamento al servizio e il servizio GKE separatamente.

1. Elimina l'allegato di servizio:

   kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false
   

   Questo comando contrassegna il collegamento di servizio per l'eliminazione, ma la risorsa continua a esistere. Puoi anche attendere il completamento dell'eliminazione omettendo il flag --wait.

2. Elimina il servizio:

   kubectl delete svc SERVICE_NAME
   

3. Elimina la subnet:

   gcloud compute networks subnets delete SUBNET_NAME
   

ServiceAttachment campi

ServiceAttachment ha i seguenti campi:

• connectionPreference: la preferenza di connessione che determina il modo in cui i clienti si connettono al servizio. Puoi utilizzare l'approvazione automatica dei progetti tramite ACCEPT_AUTOMATIC o l'approvazione esplicita dei progetti tramite ACCEPT_MANUAL. Per ulteriori informazioni, consulta Pubblicazione di servizi tramite Private Service Connect.
• natSubnets: un elenco di nomi di risorse di subnet da utilizzare per il collegamento del servizio.
• proxyProtocol: se impostato su true, l'IP di origine del consumer e l'ID connessione Private Service Connect sono disponibili nelle richieste. Questo campo è facoltativo e viene impostato su false come valore predefinito se non viene fornito.
• consumerAllowList: l'elenco dei progetti consumer autorizzati a connettersi a ServiceAttachment. Questo campo può essere utilizzato solo quando connectionPreference è ACCEPT_MANUAL. Per ulteriori informazioni su questo campo, consulta Pubblicazione di servizi tramite Private Service Connect.
  • project: l'ID o il numero del progetto consumer.
  • connectionLimit: il limite di connessione per il progetto consumer. Questo campo è facoltativo.
  • forceSendFields: i nomi dei campi da inviare da includere nelle richieste API. Questo campo è facoltativo.
  • nullFields: i nomi dei campi da includere nelle richieste API con un valore nullo. Questo campo è facoltativo.
• consumerRejectList: l'elenco degli ID o dei numeri dei progetti consumer a cui non è consentito connettersi a ServiceAttachment. Questo campo può essere utilizzato solo quando connectionPreference è ACCEPT_MANUAL. Per ulteriori informazioni su questo campo, consulta Pubblicazione di servizi tramite Private Service Connect.

• resourceRef: un riferimento alla risorsa Kubernetes.

  • kind: il tipo di risorsa Kubernetes. Devi utilizzare Service.
  • name: il nome della risorsa Kubernetes che deve trovarsi nello stesso spazio dei nomi del bilanciatore del carico di rete passthrough interno.

Risoluzione dei problemi

Puoi visualizzare i messaggi di errore utilizzando il seguente comando:

kubectl get events -n NAMESPACE

Sostituisci NAMESPACE con lo spazio dei nomi del bilanciatore del carico di rete passthrough interno.

Se provi a eliminare un bilanciatore del carico di rete passthrough interno utilizzato da un collegamento del servizio, viene visualizzato un messaggio di errore simile al seguente. Prima di eliminare il bilanciatore del carico di rete passthrough interno, devi eliminare ServiceAttachment.

Error syncing load balancer: failed to ensure load balancer: googleapi:
Error 400: The forwarding_rule resource '<fwd-rule-URL>' is already being used
by '<svc-attachment-URL>', resourceInUseByAnotherResource.

Passaggi successivi

• Leggi la panoramica della rete GKE.
• Scopri di più sui bilanciatori del carico di Compute Engine.
• Scopri come creare un cluster nativo di VPC.
• Scopri di più sulla configurazione delle reti autorizzate.
• Risolvi i problemi di bilanciamento del carico in GKE.