Configura Ingress per i bilanciatori del carico delle applicazioni esterni

Questa pagina mostra come configurare un bilanciatore del carico delle applicazioni esterno creando un oggetto Ingress Kubernetes.

Prima di leggere questa pagina, assicurati di conoscere i concetti di networking di GKE .

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à, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
  • Assicurati di avere un cluster Autopilot o Standard esistente. Per creare un nuovo cluster, vedi Crea un cluster Autopilot.

Abilita l'add-on HttpLoadBalancing

Il cluster deve avere l'add-on HttpLoadBalancing abilitato. Questo add-on è abilitato per impostazione predefinita. Nei cluster Autopilot, non puoi disattivare questo add-on.

Puoi abilitare l'add-on HttpLoadBalancing utilizzando la Google Cloud console o la Google Cloud CLI.

Console

  1. Vai alla pagina Google Kubernetes Engine nella Google Cloud console.

    Vai a Google Kubernetes Engine

  2. Fai clic sul nome del cluster da modificare.

  3. In Networking, nel campo Bilanciamento del carico HTTP, fai clic su Modifica bilanciamento del carico HTTP.

  4. Seleziona la casella di controllo Abilita bilanciamento del carico HTTP.

  5. Fai clic su Salva modifiche.

gcloud

gcloud container clusters update CLUSTER_NAME --update-addons=HttpLoadBalancing=ENABLED

Sostituisci CLUSTER_NAME con il nome del cluster.

Crea un indirizzo IP statico

Un bilanciatore del carico delle applicazioni esterno fornisce un indirizzo IP stabile che puoi utilizzare per instradare le richieste a uno o più servizi. Se vuoi un indirizzo IP permanente, devi prenotare un indirizzo IP esterno statico globale prima di creare un Ingress.

Se modifichi un Ingress esistente in modo che utilizzi un indirizzo IP statico anziché un indirizzo IP temporaneo, GKE potrebbe modificare l'indirizzo IP del bilanciatore del carico quando GKE ricrea la regola di forwarding del bilanciatore del carico.

Crea un bilanciatore del carico delle applicazioni esterno

In questo esercizio, configurerai un bilanciatore del carico delle applicazioni esterno per instradare le richieste a servizi diversi a seconda del percorso dell'URL.

Per seguire le indicazioni dettagliate per questa attività direttamente nella Google Cloud console, fai clic su Procedura guidata:

Procedura guidata

Crea deployment e servizi

Crea due deployment con servizi denominati hello-world-1 e hello-world-2:

  1. Salva il seguente manifest come hello-world-deployment-1.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment-1
spec:
  selector:
    matchLabels:
      greeting: hello
      version: one
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        version: one
    spec:
      containers:
      - name: hello-app-1
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0"
        env:
        - name: "PORT"
          value: "50000"

    Questo manifest descrive un deployment di esempio con tre repliche.

  2. Applica il manifest al cluster:

    kubectl apply -f hello-world-deployment-1.yaml

  3. Salva il seguente manifest come hello-world-service-1.yaml:

    apiVersion: v1
kind: Service
metadata:
  name: hello-world-1
spec:
  type: NodePort
  selector:
    greeting: hello
    version: one
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50000

    Questo manifest descrive un servizio con le seguenti proprietà:

    • Qualsiasi pod con l'etichetta greeting: hello e l'etichetta version: one è membro del servizio.
    • GKE inoltra le richieste inviate al servizio sulla porta TCP 60000 a uno dei pod membri sulla porta TCP 50000.
    • Il tipo di servizio è NodePort, che è obbligatorio a meno che tu non stia utilizzando il bilanciamento del carico nativo del container. Se utilizzi il bilanciamento del carico nativo del container, non ci sono restrizioni sul tipo di servizio, ma ti consigliamo di utilizzare un servizio di type ClusterIP a meno che tu non abbia bisogno esplicitamente della porta del nodo fornita da un servizio NodePort. I servizi LoadBalancer non sono supportati come backend Ingress.

  4. Applica il manifest al cluster:

    kubectl apply -f hello-world-service-1.yaml

  5. Salva il seguente manifest come hello-world-deployment-2.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment-2
spec:
  selector:
    matchLabels:
      greeting: hello
      version: two
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        version: two
    spec:
      containers:
      - name: hello-app-2
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
        env:
        - name: "PORT"
          value: "8080"

    Questo manifest descrive un deployment di esempio con tre repliche.

  6. Applica il manifest al cluster:

    kubectl apply -f hello-world-deployment-2.yaml

  7. Salva il seguente manifest come hello-world-service-2.yaml:

    apiVersion: v1
kind: Service
metadata:
  name: hello-world-2
spec:
  type: NodePort
  selector:
    greeting: hello
    version: two
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

    Questo manifest descrive un servizio con le seguenti proprietà:

    • Qualsiasi pod con l'etichetta greeting: hello e l'etichetta version: two è membro del servizio.
    • GKE inoltra le richieste inviate al servizio sulla porta TCP 80 a uno dei pod membri sulla porta TCP 8080.

  8. Applica il manifest al cluster:

    kubectl apply -f hello-world-service-2.yaml

Crea un Ingress

Crea un Ingress che specifichi le regole per l'instradamento delle richieste a seconda del percorso dell'URL nella richiesta. Quando crei l'Ingress, il controller Ingress di GKE crea e configura un bilanciatore del carico delle applicazioni esterno.

  1. Salva il seguente manifest come my-ingress.yaml:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    # If the class annotation is not specified it defaults to "gce".
    kubernetes.io/ingress.class: "gce"
spec:
  rules:
  - http:
      paths:
      - path: /*
        pathType: ImplementationSpecific
        backend:
          service:
            name: hello-world-1
            port:
              number: 60000
      - path: /v2
        pathType: ImplementationSpecific
        backend:
          service:
            name: hello-world-2
            port:
              number: 80

    Questo manifest descrive un Ingress con le seguenti proprietà:

    • Esistono due classi Ingress di GKE. Per specificare una classe Ingress, devi utilizzare l'annotazione kubernetes.io/ingress.class. Non puoi specificare un Ingress GKE utilizzando spec.ingressClassName.

    • La classe gce esegue il deployment di un bilanciatore del carico delle applicazioni esterno.

    • La classe gce-internal esegue il deployment di un bilanciatore del carico delle applicazioni interno.

    • Quando esegui il deployment di una risorsa Ingress senza le annotazioni spec.ingressClassName e kubernetes.io/ingress.class, GKE crea un bilanciatore del carico delle applicazioni esterno. Questo è lo stesso comportamento che si verifica se specifichi l'annotazione kubernetes.io/ingress.class: gce. Per saperne di più, consulta Comportamento del controller Ingress di GKE.

    • GKE crea un Google Cloud servizio di backend per ogni backend.service. Ognuno dei servizi di backend corrisponde a un servizio Kubernetes e ogni servizio di backend deve fare riferimento a un Google Cloud controllo di integrità. Questo controllo di integrità è diverso da un probe di attività o idoneità di Kubernetes perché il controllo di integrità viene implementato al di fuori del cluster. Per saperne di più, consulta Controlli di integrità

    • Quando un client invia una richiesta al bilanciatore del carico con percorso dell'URL /, GKE inoltra la richiesta al servizio hello-world-1 sulla porta 60000. Quando un client invia una richiesta al bilanciatore del carico utilizzando il percorso dell'URL /v2, GKE inoltra la richiesta al servizio hello-world-2 sulla porta 80. Per saperne di più sulle proprietà path e pathType, consulta Percorsi URL.

    • Se vuoi prenotare un indirizzo IP esterno statico globale, includi un' kubernetes.io/ingress.global-static-ip-name annotazione nell'oggetto Ingress come mostrato qui:

     apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
   name: my-ingress
   annotations:
     kubernetes.io/ingress.global-static-ip-name: my-static-address
 ```

  2. Applica il manifest al cluster:

    kubectl apply -f my-ingress.yaml

Testa il bilanciatore del carico delle applicazioni esterno

Attendi circa cinque minuti per la configurazione del bilanciatore del carico, quindi testa il bilanciatore del carico delle applicazioni esterno:

  1. Visualizza l'Ingress:

    kubectl get ingress my-ingress --output yaml

    L'output mostra l'indirizzo IP del bilanciatore del carico delle applicazioni esterno:

    status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

  2. Testa il percorso /:

    curl LOAD_BALANCER_IP_ADDRESS/

    Sostituisci LOAD_BALANCER_IP_ADDRESS con l'indirizzo IP esterno del bilanciatore del carico.

    L'output è simile al seguente:

    Hello, world!
Version: 1.0.0
Hostname: ...

    Se l'output include un errore 404, attendi qualche minuto.

  3. Testa il percorso /v2:

    curl load-balancer-ip/v2

    L'output è simile al seguente:

    Hello, world!
Version: 2.0.0
Hostname: ...

Come funziona Ingress per il bilanciamento del carico esterno

Questa sezione descrive i componenti e le configurazioni che consentono il bilanciamento del carico esterno per le applicazioni GKE, tra cui la corrispondenza del percorso dell'URL, i gruppi di endpoint di rete e l'integrazione di VPC condiviso.

Percorsi URL

L'unico carattere jolly supportato per il campo path di un Ingress è il carattere *. Il carattere * deve seguire una barra (/) e deve essere l'ultimo carattere nel pattern. Ad esempio, /*, /foo/* e /foo/bar/* sono pattern validi, ma *, /foo/bar* e /foo/*/bar non lo sono.

Un pattern più specifico ha la precedenza su un pattern meno specifico. Se hai sia /foo/* sia /foo/bar/*, allora /foo/bar/bat viene considerato corrispondente a /foo/bar/*. Per saperne di più sulle limitazioni del percorso e sulla corrispondenza dei pattern, consulta la documentazione relativa alle mappe URL.

Per i cluster GKE che eseguono versioni precedenti alla 1.21.3-gke.1600, l'unico valore supportato per il campo pathType è ImplementationSpecific. Per i cluster che eseguono la versione 1.21.3-gke.1600 o successive, i valori Prefix e Exact sono supportati anche per pathType.

Gruppi di endpoint di rete

Se il cluster supporta il bilanciamento del carico nativo del container, ti consigliamo di utilizzare i gruppi di endpoint di rete (NEG). Quando crei l'Ingress, GKE crea un bilanciatore del carico delle applicazioni nel progetto e i NEG vengono creati in ogni zona in cui viene eseguito il cluster. Gli endpoint nel NEG e gli endpoint del servizio vengono mantenuti sincronizzati. Per i cluster GKE 1.17 e versioni successive, il bilanciamento del carico nativo del container è predefinito e non richiede un'annotazione di servizio cloud.google.com/neg: '{"ingress": true}'esplicita, in determinate condizioni. Per i cluster in cui i NEG non sono predefiniti, ti consigliamo vivamente di utilizzare il bilanciamento del carico nativo del container, ma deve essere abilitato in modo esplicito per ogni servizio. L'annotazione deve essere applicata ai servizi nel seguente modo:

kind: Service
...
  annotations:
    cloud.google.com/neg: '{"ingress": true}'
...

Quando aggiungi questa annotazione, viene creato un nuovo BackendService per il servizio esistente. Ciò può comportare un'interruzione temporanea del servizio.

VPC condiviso

Se il cluster GKE in cui esegui il deployment delle risorse Ingress si trova in un progetto di servizio, e vuoi che il piano di controllo GKE gestisca le risorse firewall nel progetto host, al service account GKE del progetto di servizio devono essere concesse le autorizzazioni IAM appropriate nel progetto host come descritto in Gestire le risorse firewall per i cluster con VPC condiviso. In questo modo, il controller Ingress può creare regole firewall per consentire sia il traffico in entrata sia il traffico per i Google Cloud controlli di integrità.

Di seguito è riportato un esempio di evento che potrebbe essere presente nei log delle risorse Ingress. Questo errore si verifica quando il controller Ingress non è in grado di creare una regola firewall per consentire il traffico in entrata per i Google Cloud controlli di integrità se le autorizzazioni non sono configurate correttamente.

Firewall change required by security admin: `gcloud compute firewall-rules update <RULE_NAME> --description "GCE L7 firewall rule" --allow tcp:<PORT> --source-ranges 130.211.0.0/22,35.191.0.0/16 --target-tags <TARGET_TAG> --project <HOST_PROJECT>

Se preferisci eseguire il provisioning manuale delle regole firewall dall'host progetto, puoi disattivare gli eventi firewallXPNError aggiungendo l' networking.gke.io/suppress-firewall-xpn-error: "true" annotazione alla risorsa Ingress.

Riepilogo delle annotazioni Ingress esterne

Puoi utilizzare le seguenti annotazioni per configurare il comportamento delle risorse Ingress esterne e degli oggetti di servizio Kubernetes associati.

Annotazioni Ingress

Annotazione Descrizione
kubernetes.io/ingress.allow-http Specifica se consentire il traffico HTTP tra il client e il bilanciatore del carico HTTP(S) . I valori possibili sono "true" e "false". Il valore predefinito è "true". Consulta Disattivare HTTP.
ingress.gcp.kubernetes.io/pre-shared-cert Utilizza questa annotazione per collegare le risorse dei certificati alle risorse Ingress di GKE. Per saperne di più, consulta Utilizzare più certificati SSL con i bilanciatori del carico delle applicazioni esterni.
kubernetes.io/ingress.global-static-ip-name Utilizza questa annotazione per specificare che il bilanciatore del carico deve utilizzare un indirizzo IP esterno statico creato in precedenza. Consulta Indirizzi IP statici per i bilanciatori del carico HTTP(S).
networking.gke.io/v1beta1.FrontendConfig Utilizza questa annotazione per personalizzare la configurazione del bilanciatore del carico rivolta al client. Per saperne di più, consulta Configurazione di Ingress.
networking.gke.io/suppress-firewall-xpn-error Per i bilanciatori del carico Ingress, se Kubernetes non può modificare le regole firewall a causa di autorizzazioni insufficienti, viene creato un evento firewallXPNError ogni pochi minuti. In GLBC 1.4 e versioni successive, puoi disattivare l'evento firewallXPNError aggiungendo l'annotazione networking.gke.io/suppress-firewall-xpn-error: "true" alla risorsa Ingress. Puoi rimuovere questa annotazione per riattivare l'evento. I valori possibili sono true e false. Il valore predefinito è false.
Annotazione Descrizione
cloud.google.com/app-protocols Utilizza questa annotazione per impostare il protocollo per la comunicazione tra il bilanciatore del carico e l'applicazione. I protocolli possibili sono HTTP, HTTPS e HTTP2.
cloud.google.com/backend-config Utilizza questa annotazione per configurare il servizio di backend associato a un servizio. Per saperne di più, consulta Configurazione di Ingress.
cloud.google.com/neg Utilizza questa annotazione per specificare che il bilanciatore del carico deve utilizzare i gruppi di endpoint di rete. Consulta Utilizzare il bilanciamento del carico nativo del container.

Passaggi successivi