Esegui il deployment di un'applicazione containerizzata ad alta disponibilità

Questo documento descrive come eseguire il deployment di un'applicazione container Kubernetes ad alta affidabilità (HA) in Google Distributed Cloud (GDC) con air gap. Per garantire la resilienza, devi eseguire il deployment dell'applicazione in più zone e configurare la replica dello spazio di archiviazione in modo che l'applicazione e i relativi dati siano recuperabili in caso di tempi di inattività imprevisti o di un disaster recovery locale.

Questo documento è rivolto agli sviluppatori di applicazioni responsabili della creazione di workload containerizzati resilienti.

Per saperne di più, consulta la documentazione sui segmenti di pubblico per GDC con air gap.

Obiettivi

  • Crea un cluster Kubernetes in due o più zone nel tuo universo GDC.
  • Configura il bilanciamento del carico globale.
  • Eseguire il deployment dei workload dei container in ogni cluster Kubernetes a livello di zona.
  • Esegui il provisioning dello spazio di archiviazione e collegalo ai tuoi pod.
  • Configura la replica dello spazio di archiviazione utilizzando l'archiviazione a blocchi o l'archiviazione di oggetti.

Prima di iniziare

Per prepararti alle attività descritte in questo documento, devi ottenere le autorizzazioni necessarie e verificare l'ambiente.

Richiedi ruoli e autorizzazioni IAM

Contatta l'amministratore dell'organizzazione IAM per richiedere i seguenti ruoli:

  • Namespace Admin (namespace-admin): crea e modifica i workload dei container in un cluster condiviso.
  • Amministratore cluster utente (user-cluster-admin): crea e modifica i cluster condivisi.
  • User Cluster Developer (user-cluster-developer): crea e modifica i node pool in un cluster condiviso.
  • Amministratore istanza Harbor (harbor-instance-admin): crea e modifica istanze Harbor, progetti Harbor e immagini container.
  • Project Network Policy Admin (global-project-networkpolicy-admin): crea e modifica le policy di rete del progetto in tutte le zone.
  • Global Load Balancer Admin (global-load-balancer-admin): crea e modifica i bilanciatori del carico globali.
  • Amministratore globale della replica dei volumi (app-volume-replication-admin-global): gestisce la relazione di replica dei volumi per le risorse di archiviazione a blocchi.
  • Bucket Project Admin (global-project-bucket-admin): crea e modifica i bucket di archiviazione a doppia regione.

Per saperne di più, consulta le descrizioni dei ruoli.

prepara l'ambiente

Assicurati di disporre dei seguenti strumenti e configurazioni nel tuo ambiente con air gap:

Crea un cluster Kubernetes in più zone

Per creare un'applicazione container ad alta affidabilità, devi creare un cluster Kubernetes condiviso separato in ogni zona del tuo universo GDC.

Per saperne di più sulle opzioni di configurazione del cluster disponibili, consulta Configurazioni dei cluster Kubernetes.

Console

  1. Nel menu di navigazione, seleziona Kubernetes Engine > Cluster.

  2. Fai clic su Crea cluster.

  3. Nel campo Nome, specifica un nome per il cluster.

  4. Seleziona la versione di Kubernetes per il cluster.

  5. Seleziona la zona in cui creare il cluster.

  6. Fai clic su Collega progetto e seleziona un progetto esistente da collegare al tuo cluster. Quindi, fai clic su Salva. Puoi collegare o scollegare i progetti dopo aver creato il cluster dalla pagina Dettagli progetto. Devi avere un progetto collegato al cluster prima di eseguire il deployment dei workload dei container.

  7. Fai clic su Avanti.

  8. Configura le impostazioni della rete per il cluster. Non puoi modificare queste impostazioni della rete dopo aver creato il cluster. L'Internet Protocol predefinito e l'unico supportato per i cluster Kubernetes è Internet Protocol versione 4 (IPv4).

    1. Specifica la dimensione del pool di indirizzi IP del bilanciatore del carico, ad esempio 20.

    2. Seleziona il CIDR (Classless Inter-Domain Routing) del servizio da utilizzare. Ai tuoi servizi di cui è stato eseguito il deployment, come i bilanciatori del carico, vengono allocati indirizzi IP di questo intervallo.

    3. Seleziona il CIDR del pod da utilizzare. Il cluster assegna gli indirizzi IP di questo intervallo ai pod e alle VM.

    4. Fai clic su Avanti.

  9. Esamina i dettagli del pool di nodi predefinito generato automaticamente per il cluster. Fai clic su Modifica per modificare il pool di nodi predefinito.

  10. Per creare altri node pool, seleziona Aggiungi node pool. Quando modifichi il pool di nodi predefinito o ne aggiungi uno nuovo, puoi personalizzarlo con le seguenti opzioni:

    1. Assegna un nome al pool di nodi. Non puoi modificare il nome dopo aver creato il pool di nodi.
    2. Specifica il numero di nodi worker da creare nel pool di nodi.
    3. Seleziona la classe di macchina più adatta ai requisiti del tuo workload. Visualizza l'elenco delle seguenti impostazioni:

      • Tipo di macchina
      • CPU
      • Memoria
    4. Fai clic su Salva.

    5. Fai clic su Crea per creare il cluster.

  11. Ripeti questi passaggi per ogni zona nell'universo GDC. Assicurati che in ogni zona che vuoi per la tua strategia di alta affidabilità sia presente un cluster Kubernetes.

API

Per creare un nuovo cluster Kubernetes utilizzando direttamente l'API, applica una risorsa personalizzata a ogni zona GDC.

  1. Crea una risorsa personalizzata Cluster ed eseguine il deployment sul server dell'API di gestione per la tua zona:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: cluster.gdc.goog/v1
    kind: Cluster
    metadata:
      name: CLUSTER_NAME
      namespace: platform
    spec:
      clusterNetwork:
        podCIDRSize: POD_CIDR
        serviceCIDRSize: SERVICE_CIDR
      initialVersion:
        kubernetesVersion: KUBERNETES_VERSION
      nodePools:
      - machineTypeName: MACHINE_TYPE
        name: NODE_POOL_NAME
        nodeCount: NUMBER_OF_WORKER_NODES
        taints: TAINTS
        labels: LABELS
        acceleratorOptions:
          gpuPartitionScheme: GPU_PARTITION_SCHEME
      releaseChannel:
        channel: UNSPECIFIED
    EOF
    

    Sostituisci quanto segue:

    • MANAGEMENT_API_SERVER: il percorso kubeconfig del server API di gestione a livello di zona. Per saperne di più, consulta Passa al contesto di zona.
    • CLUSTER_NAME: il nome del cluster. Il nome del cluster non deve terminare con -system. Il suffisso -system è riservato ai cluster creati da GDC.
    • POD_CIDR: la dimensione degli intervalli di rete da cui vengono allocati gli indirizzi IP virtuali (VIP) dei pod. Se non viene impostato, viene utilizzato il valore predefinito 21.
    • SERVICE_CIDR: la dimensione degli intervalli di rete da cui vengono allocati i VIP del servizio. Se non viene impostato, viene utilizzato il valore predefinito 23.
    • KUBERNETES_VERSION: la versione di Kubernetes del cluster, ad esempio 1.26.5-gke.2100. Per elencare le versioni di Kubernetes disponibili da configurare, consulta Elenca le versioni di Kubernetes disponibili per un cluster.
    • MACHINE_TYPE: il tipo di macchina per i nodi worker del pool di nodi. Consulta i tipi di macchine disponibili per scoprire cosa puoi configurare.
    • NODE_POOL_NAME: il nome del pool di nodi.
    • NUMBER_OF_WORKER_NODES: il numero di nodi worker di cui eseguire il provisioning nel pool di nodi.
    • TAINTS: i taint da applicare ai nodi di questo pool di nodi. Questo è un campo facoltativo.
    • LABELS: le etichette da applicare ai nodi di questo pool di nodi. Contiene un elenco di coppie chiave-valore. Questo è un campo facoltativo.
    • GPU_PARTITION_SCHEME: lo schema di partizionamento della GPU, se esegui workload GPU, ad esempio mixed-2. La GPU non viene partizionata se questo campo non è impostato. Per i profili GPU multi-istanza (MIG) disponibili, consulta Profili MIG supportati.
  2. Ripeti il passaggio precedente per ogni zona in cui vuoi ospitare la tua applicazione container per la tua strategia HA.

Configura i bilanciatori del carico

Per distribuire il traffico tra i pod in zone diverse, crea dei bilanciatori del carico. Puoi configurare i bilanciatori del carico sia interni che esterni a livello globale per assicurarti che le richieste dei client vengano indirizzate a zone integre.

Crea un bilanciatore del carico interno globale

I bilanciatori del carico interni (ILB) espongono i servizi all'interno dell'organizzazione da un pool di indirizzi IP interni assegnato all'organizzazione. Un servizio ILB non è mai accessibile da un endpoint esterno all'organizzazione.

Completa i seguenti passaggi per creare un bilanciatore del carico interno globale per i workload dei container.

gdcloud

Crea un bilanciatore del carico interno che ha come target i workload dei pod utilizzando la CLI gdcloud.

Questo ILB ha come target tutti i workload del progetto che corrispondono all'etichetta definita nell'oggetto Backend. La risorsa personalizzata Backend deve avere come ambito una zona.

Per creare un bilanciatore del carico interno utilizzando la CLI gdcloud, segui questi passaggi:

  1. Crea una risorsa Backend di zona in ogni zona in cui sono in esecuzione i pod per definire l'endpoint per l'ILB:

    gdcloud compute backends create BACKEND_NAME \
        --labels=LABELS \
        --project=PROJECT \
        --cluster-name=CLUSTER_NAME \
        --zone=ZONE
    

    Sostituisci quanto segue:

    • BACKEND_NAME: il nome scelto per la risorsa di backend, ad esempio my-backend.
    • LABELS: il selettore che definisce quali endpoint tra i pod utilizzare per questa risorsa di backend, ad esempio app=web.
    • PROJECT: il nome del progetto.
    • CLUSTER_NAME: il cluster Kubernetes a cui è limitato l'ambito dei selettori definiti. Se questo campo non viene specificato, vengono selezionati tutti gli endpoint con l'etichetta specificata. Questo campo è facoltativo.
    • ZONE: la zona da utilizzare per questa chiamata. Per preimpostare il flag della zona per tutti i comandi che lo richiedono, esegui gdcloud config set core/zone ZONE. Il flag zone è disponibile solo in ambienti multizona. Questo campo è facoltativo.

    Ripeti questo passaggio per ogni zona del tuo universo GDC.

  2. Crea una risorsa BackendService globale:

    gdcloud compute backend-services create BACKEND_SERVICE_NAME \
        --project=PROJECT \
        --target-ports=TARGET_PORTS \
        --global
    

    Sostituisci quanto segue:

    • BACKEND_SERVICE_NAME: il nome del servizio di backend.
    • PROJECT: il nome del progetto.
    • TARGET_PORTS: un elenco separato da virgole di porte di destinazione tradotte da questo servizio di backend, dove ogni porta di destinazione specifica il protocollo, la porta nella regola di forwarding e la porta nell'istanza di backend. Puoi specificare più porte di destinazione. Questo campo deve essere nel formato protocol:port:targetport, ad esempio TCP:80:8080. Questo campo è facoltativo.
  3. Aggiungi la risorsa BackendService alla risorsa Backend creata in precedenza in ogni zona:

    gdcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
        --backend-zone=ZONE \
        --backend=BACKEND_NAME \
        --project=PROJECT \
        --global
    

    Sostituisci quanto segue:

    • BACKEND_SERVICE_NAME: il nome del servizio di backend globale.
    • ZONE: la zona del backend.
    • BACKEND_NAME: il nome del backend di zona.
    • PROJECT: il nome del progetto.

    Completa questo passaggio per ogni backend di zona creato in precedenza.

  4. Crea una risorsa ForwardingRule interna che definisce l'indirizzo IP virtuale (VIP) in cui è disponibile il servizio:

    gdcloud compute forwarding-rules create FORWARDING_RULE_INTERNAL_NAME \
        --backend-service=BACKEND_SERVICE_NAME \
        --cidr=CIDR \
        --ip-protocol-port=PROTOCOL_PORT \
        --load-balancing-scheme=INTERNAL \
        --project=PROJECT \
        --global
    

    Sostituisci quanto segue:

    • FORWARDING_RULE_INTERNAL_NAME: il nome della regola di forwarding.
    • CIDR: il CIDR da utilizzare per la regola di forwarding. Questo campo è facoltativo. Se non specificato, viene riservato automaticamente un CIDR IPv4/32 dal pool di indirizzi IP globali. Specifica il nome di una risorsa Subnet nello stesso spazio dei nomi di questa regola di forwarding. Una risorsa Subnet rappresenta le informazioni di richiesta e allocazione di una subnet globale. Per saperne di più sulle risorse Subnet, consulta Gestisci le subnet.
    • PROTOCOL_PORT: il protocollo e la porta da esporre nella regola di forwarding. Questo campo deve essere nel formato ip-protocol=TCP:80. La porta esposta deve essere la stessa esposta dall'applicazione effettiva all'interno del container.
  5. Per convalidare l'ILB configurato, verifica la condizione Ready su ciascuno degli oggetti creati. Verifica il traffico con una richiesta curl al VIP:

    1. Per ottenere il VIP assegnato, descrivi la regola di forwarding:

      gdcloud compute forwarding-rules describe FORWARDING_RULE_INTERNAL_NAME --global
      
    2. Verifica il traffico con una richiesta curl al VIP sulla porta specificata nel campo della regola di forwarding:

      curl http://FORWARDING_RULE_VIP:PORT
      

    Sostituisci quanto segue:

    • FORWARDING_RULE_VIP: il VIP della regola di forwarding.
    • PORT: il numero di porta della regola di forwarding.

API

Crea un bilanciatore del carico interno che ha come target i workload dei container utilizzando l'API KRM. Questo ILB ha come target tutti i workload del progetto che corrispondono all'etichetta definita nell'oggetto Backend. Per creare un ILB globale utilizzando l'API KRM, segui questi passaggi:

  1. Crea una risorsa Backend per definire gli endpoint per l'ILB. Crea risorse Backend per ogni zona in cui sono posizionati i workload dei container:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      clusterName: CLUSTER_NAME
      endpointsLabels:
        matchLabels:
          app: APP_NAME
    EOF
    

    Sostituisci quanto segue:

    • MANAGEMENT_API_SERVER: il percorso kubeconfig del server API di gestione a livello di zona. Per saperne di più, consulta Passa a un contesto di zona.
    • PROJECT: il nome del progetto.
    • BACKEND_NAME: il nome della risorsa Backend.
    • CLUSTER_NAME: il cluster Kubernetes a cui è limitato l'ambito dei selettori definiti. Se questo campo non viene specificato, vengono selezionati tutti gli endpoint con l'etichetta specificata. Questo campo è facoltativo.
    • APP_NAME: il nome dell'applicazione container.

    Puoi utilizzare la stessa risorsa Backend per ogni zona o creare risorse Backend con set di etichette diversi per ogni zona.

  2. Crea un oggetto BackendService utilizzando la risorsa Backend creata in precedenza. Assicurati di includere la risorsa HealthCheck:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: BackendService
    metadata:
      namespace: PROJECT
      name: BACKEND_SERVICE_NAME
    spec:
      backendRefs:
      - name: BACKEND_NAME
        zone: ZONE
      healthCheckName: HEALTH_CHECK_NAME
      targetPorts:
      - port: PORT
        protocol: PROTOCOL
        targetPort: TARGET_PORT
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il percorso kubeconfig del server API globale.
    • PROJECT: il nome del progetto.
    • BACKEND_SERVICE_NAME: il nome scelto per la risorsa BackendService.
    • HEALTH_CHECK_NAME: il nome della risorsa HealthCheck creata in precedenza.
    • BACKEND_NAME: il nome della risorsa Backend a livello di zona.
    • ZONE: la zona in cui si trova la risorsa Backend. Puoi specificare più backend nel campo backendRefs. Ad esempio:

      - name: my-backend-1
        zone: us-east1-a
      - name: my-backend-2
        zone: us-east1-b
      

      Il campo targetPorts è facoltativo. Questa risorsa elenca le porte tradotte da questa risorsa BackendService. Se utilizzi questo oggetto, fornisci i valori per i seguenti elementi:

    • PORT: la porta esposta dal servizio.

    • PROTOCOL: il protocollo di livello 4 a cui deve corrispondere il traffico. Sono supportati solo i protocolli TCP e UDP.

    • TARGET_PORT: la porta in cui viene tradotto il valore, ad esempio 8080. Il valore non può essere ripetuto in un determinato oggetto.

      Un esempio di targetPorts potrebbe essere il seguente:

      targetPorts:
        - port: 80
          protocol: TCP
          targetPort: 8080
      
  3. Crea una risorsa ForwardingRule interna che definisca l'indirizzo IP virtuale (VIP) in cui è disponibile il servizio.

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ForwardingRuleInternal
    metadata:
      namespace: PROJECT
      name: FORWARDING_RULE_INTERNAL_NAME
    spec:
      cidrRef:
        name: CIDR_NAME
      ports:
      - port: PORT
        protocol: PROTOCOL
      backendServiceRef:
        name: BACKEND_SERVICE_NAME
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il percorso kubeconfig del server API globale.
    • PROJECT: il nome del progetto.
    • FORWARDING_RULE_INTERNAL_NAME: il nome scelto per la risorsa ForwardingRuleInternal.
    • CIDR_NAME: il nome del CIDR da utilizzare per la regola di forwarding. Questo campo è facoltativo. Se non specificato, viene riservato automaticamente un CIDR IPv4/32 dal pool di indirizzi IP globali. Specifica il nome di una risorsa Subnet nello stesso spazio dei nomi di questa regola di forwarding. Una risorsa Subnet rappresenta le informazioni di richiesta e allocazione di una subnet globale. Per saperne di più sulle risorse Subnet, consulta Gestisci le subnet.
    • PORT: la porta da esporre nella regola di forwarding. Utilizza il campo ports per specificare un array di porte L4 per le quali i pacchetti vengono inoltrati ai backend configurati con questa regola di forwarding. È necessario specificare almeno una porta. Utilizza il campo port per specificare un numero di porta. La porta esposta deve essere la stessa esposta dall'applicazione effettiva all'interno del container.
    • PROTOCOL: il protocollo da utilizzare per la regola di forwarding, ad esempio TCP. Una voce nell'array ports deve avere il seguente aspetto:

      ports:
      - port: 80
        protocol: TCP
      
  4. Per convalidare l'ILB configurato, verifica la condizione Ready su ciascuno degli oggetti creati. Verifica il traffico con una richiesta curl al VIP:

    1. Recupera il VIP:

      kubectl get forwardingruleinternal -n PROJECT
      

      L'output è simile al seguente:

      NAME           BACKENDSERVICE                  CIDR              READY
      ilb-name       BACKEND_SERVICE_NAME            192.0.2.0/32      True
      
    2. Testa il traffico con una richiesta curl al VIP sulla porta specificata nel campo della regola di forwarding:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Sostituisci quanto segue:

      • FORWARDING_RULE_VIP: il VIP della regola di forwarding.
      • PORT: il numero di porta del campo nella regola di forwarding.

Crea un bilanciatore del carico esterno globale

I bilanciatori del carico esterni (ELB) espongono i servizi per l'accesso dall'esterno dell'organizzazione da un pool di indirizzi IP assegnati all'organizzazione dal pool di indirizzi IP esterni all'istanza più grande.

Completa i seguenti passaggi per creare un ELB globale per i workload dei container.

gdcloud

Utilizza la CLI gdcloud per creare un ELB globale che ha come target tutti i workload nel progetto corrispondenti all'etichetta definita nell'oggetto Backend. La risorsa personalizzata Backend deve avere come ambito una zona.

  1. Affinché i servizi ELB funzionino, devi configurare e applicare una policy di trasferimento di dati in ingresso ProjectNetworkPolicy personalizzata per consentire il traffico verso i workload di questo servizio ELB. Le policy di rete controllano l'accesso ai tuoi workload, non al bilanciatore del carico stesso. Gli ELB espongono i workload alla rete dei clienti, richiedendo policy di rete esplicite per consentire il traffico esterno alla porta del workload, ad esempio 8080.

    Specifica l'indirizzo CIDR esterno per consentire il traffico verso i workload di questo ELB:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ProjectNetworkPolicy
    metadata:
      namespace: PROJECT
      name: allow-inbound-traffic-from-external
    spec:
      policyType: Ingress
      subject:
        subjectType: UserWorkload
      ingress:
      - from:
        - ipBlock:
            cidr: CIDR
        ports:
        - protocol: TCP
          port: PORT
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il percorso kubeconfig del percorso kubeconfig del server API globale. Se non hai ancora generato un file kubeconfig per il server API globale, consulta Genera manualmente il file kubeconfig per i dettagli.
    • PROJECT: il nome del progetto.
    • CIDR: il CIDR esterno da cui deve essere eseguito l'accesso all'ELB. Questa policy è obbligatoria perché il bilanciatore del carico esterno utilizza Direct Server Return (DSR), che conserva l'indirizzo IP esterno di origine e ignora il bilanciatore del carico nel percorso di ritorno. Per saperne di più, consulta Crea una regola firewall in entrata globale per il traffico esterno all'organizzazione.
    • PORT: la porta di backend sui pod dietro il bilanciatore del carico. Questo valore si trova nel campo .spec.ports[].targetPortfield del manifest della risorsa Service. Questo campo è facoltativo.

    Questa configurazione fornisce a tutte le risorse all'interno dei progetti l'accesso all'intervallo CIDR specificato.

  2. Crea una risorsa Backend in ogni zona per definire l'endpoint per l'ELB:

    gdcloud compute backends create BACKEND_NAME \
      --labels=LABELS \
      --project=PROJECT \
      --cluster-name=CLUSTER_NAME \
      --zone=ZONE
    

    Sostituisci quanto segue:

    • BACKEND_NAME: il nome della risorsa di backend, ad esempio my-backend.
    • LABELS: un selettore che definisce quali endpoint tra i pod utilizzare per questa risorsa di backend, ad esempio app=web.
    • PROJECT: il nome del progetto.
    • CLUSTER_NAME: il cluster Kubernetes a cui è limitato l'ambito dei selettori definiti. Se questo campo non viene specificato, vengono selezionati tutti gli endpoint con l'etichetta specificata. Questo campo è facoltativo.
    • ZONE: la zona da utilizzare per questa chiamata. Per preimpostare il flag della zona per tutti i comandi che lo richiedono, esegui gdcloud config set core/zone ZONE. Il flag zone è disponibile solo in ambienti multizona. Questo campo è facoltativo.

    Puoi utilizzare la stessa risorsa Backend per ogni zona o creare risorse Backend con set di etichette diversi per ogni zona.

  3. Crea una risorsa BackendService globale:

    gdcloud compute backend-services create BACKEND_SERVICE_NAME \
      --project=PROJECT \
      --target-ports=TARGET_PORTS \
      --health-check=HEALTH_CHECK_NAME \
      --global
    

    Sostituisci quanto segue:

    • BACKEND_SERVICE_NAME: il nome scelto per questo servizio di backend.
    • PROJECT: il nome del progetto.
    • TARGET_PORTS: un elenco separato da virgole di porte di destinazione tradotte da questo servizio di backend, dove ogni porta di destinazione specifica il protocollo, la porta sulla regola di forwarding e la porta sull'istanza di backend. Puoi specificare più porte di destinazione. Questo campo deve essere nel formato protocol:port:targetport, ad esempio TCP:80:8080. Questo campo è facoltativo.
    • HEALTH_CHECK_NAME: il nome della risorsa del controllo di integrità. Questo campo è facoltativo.
  4. Aggiungi la risorsa BackendService globale alla risorsa Backend di zona creata in precedenza:

    gdcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
      --backend=BACKEND_NAME \
      --backend-zone=ZONE \
      --project=PROJECT \
      --global
    

    Completa questo passaggio per ogni backend di zona creato in precedenza.

  5. Crea una risorsa ForwardingRule esterna che definisce il VIP in cui è disponibile il servizio:

    gdcloud compute forwarding-rules create FORWARDING_RULE_EXTERNAL_NAME \
      --backend-service=BACKEND_SERVICE_NAME \
      --cidr=CIDR \
      --ip-protocol-port=PROTOCOL_PORT \
      --load-balancing-scheme=EXTERNAL \
      --project=PROJECT \
      --global
    

    Sostituisci quanto segue:

    • FORWARDING_RULE_EXTERNAL_NAME: il nome della regola di forwarding.
    • CIDR: il CIDR da utilizzare per la regola di forwarding. Questo campo è facoltativo. Se non specificato, viene riservato automaticamente un CIDR IPv4/32 dal pool di indirizzi IP globali. Specifica il nome di una risorsa Subnet nello stesso spazio dei nomi di questa regola di forwarding. Una risorsa Subnet rappresenta le informazioni di richiesta e allocazione di una subnet globale. Per saperne di più sulle risorse Subnet, consulta Gestisci le subnet.
    • PROTOCOL_PORT: il protocollo e la porta da esporre nella regola di forwarding. Questo campo deve essere nel formato ip-protocol=TCP:80. La porta esposta deve essere la stessa esposta dall'applicazione effettiva all'interno del container.
    • PROJECT: il nome del progetto.
  6. Per convalidare l'ELB configurato, verifica la condizione Ready su ciascuno degli oggetti creati. Verifica il traffico con una richiesta curl al VIP:

    1. Per ottenere il VIP assegnato, descrivi la regola di forwarding:

      gdcloud compute forwarding-rules describe FORWARDING_RULE_EXTERNAL_NAME
      
    2. Verifica il traffico con una richiesta curl al VIP sulla porta specificata nel campo PROTOCOL_PORT della regola di forwarding:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Sostituisci quanto segue:

      • FORWARDING_RULE_VIP: il VIP della regola di forwarding.
      • PORT: il numero di porta del campo PROTOCOL_PORT nella regola di forwarding.

API

Crea un ELB che ha come target i workload dei pod utilizzando l'API KRM. Questo ELB ha come target tutti i workload del progetto che corrispondono all'etichetta definita nell'oggetto Backend. Per creare un ELB di zona utilizzando l'API KRM, segui questi passaggi:

  1. Affinché i servizi ELB funzionino, devi configurare e applicare una policy di trasferimento di dati in ingresso ProjectNetworkPolicy personalizzata per consentire il traffico verso i workload di questo servizio ELB. Le policy di rete controllano l'accesso ai tuoi workload, non al bilanciatore del carico stesso. Gli ELB espongono i workload alla rete dei clienti, richiedendo policy di rete esplicite per consentire il traffico esterno alla porta del workload, ad esempio 8080.

    Specifica l'indirizzo CIDR esterno per consentire il traffico verso i workload di questo ELB:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ProjectNetworkPolicy
    metadata:
      namespace: PROJECT
      name: allow-inbound-traffic-from-external
    spec:
      policyType: Ingress
      subject:
        subjectType: UserWorkload
      ingress:
      - from:
        - ipBlock:
            cidr: CIDR
        ports:
        - protocol: TCP
          port: PORT
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il percorso kubeconfig del percorso kubeconfig del server API globale. Se non hai ancora generato un file kubeconfig per il server API globale, consulta Genera manualmente il file kubeconfig per i dettagli.
    • PROJECT: il nome del progetto.
    • CIDR: il CIDR esterno da cui deve essere eseguito l'accesso all'ELB. Questa policy è obbligatoria perché il bilanciatore del carico esterno utilizza Direct Server Return (DSR), che conserva l'indirizzo IP esterno di origine e ignora il bilanciatore del carico nel percorso di ritorno. Per saperne di più, consulta Crea una regola firewall in entrata globale per il traffico esterno all'organizzazione.
    • PORT: la porta di backend sui pod dietro il bilanciatore del carico. Questo valore si trova nel campo .spec.ports[].targetPortfield del manifest della risorsa Service. Questo campo è facoltativo.
  2. Crea una risorsa Backend per definire gli endpoint per l'ELB. Crea risorse Backend per ogni zona in cui si trovano i workload:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      clusterName: CLUSTER_NAME
      endpointsLabels:
        matchLabels:
          app: APP_NAME
    EOF
    

    Sostituisci quanto segue:

    • MANAGEMENT_API_SERVER: il percorso kubeconfig del server API di gestione a livello di zona. Se non hai ancora generato un file kubeconfig per il server API nella zona di destinazione, consulta Genera manualmente il file kubeconfig per i dettagli.
    • PROJECT: il nome del progetto.
    • BACKEND_NAME: il nome della risorsa Backend.
    • CLUSTER_NAME: il cluster Kubernetes a cui è limitato l'ambito dei selettori definiti. Se questo campo non viene specificato, vengono selezionati tutti gli endpoint con l'etichetta specificata. Questo campo è facoltativo.
    • APP_NAME: il nome dell'applicazione container.

    Puoi utilizzare la stessa risorsa Backend per ogni zona o creare risorse Backend con set di etichette diversi per ogni zona.

  3. Crea un oggetto BackendService utilizzando la risorsa Backend creata in precedenza:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: BackendService
    metadata:
      namespace: PROJECT
      name: BACKEND_SERVICE_NAME
    spec:
      backendRefs:
      - name: BACKEND_NAME
        zone: ZONE
      healthCheckName: HEALTH_CHECK_NAME
    EOF
    

    Sostituisci quanto segue:

    • BACKEND_SERVICE_NAME: il nome scelto per la risorsa BackendService.
    • HEALTH_CHECK_NAME: il nome della risorsa HealthCheck creata in precedenza. Non includere questo campo se stai configurando un ELB per i workload dei pod.
    • ZONE: la zona in cui si trova la risorsa Backend. Puoi specificare più backend nel campo backendRefs. Ad esempio:
    - name: my-backend-1
      zone: us-east1-a
    - name: my-backend-2
      zone: us-east1-b
    

  4. Crea una risorsa ForwardingRule esterna che definisca il VIP in cui è disponibile il servizio.

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ForwardingRuleExternal
    metadata:
      namespace: PROJECT
      name: FORWARDING_RULE_EXTERNAL_NAME
    spec:
      cidrRef:
        name: CIDR_NAME
      ports:
      - port: PORT
        protocol: PROTOCOL
      backendServiceRef:
        name: BACKEND_SERVICE_NAME
    EOF
    

    Sostituisci quanto segue:

    • FORWARDING_RULE_EXTERNAL_NAME: il nome scelto per la risorsa ForwardingRuleExternal.
    • CIDR_NAME: il nome del CIDR da utilizzare per la regola di forwarding. Questo campo è facoltativo. Se non specificato, viene riservato automaticamente un CIDR IPv4/32 dal pool di indirizzi IP globali. Specifica il nome di una risorsa Subnet nello stesso spazio dei nomi di questa regola di forwarding. Una risorsa Subnet rappresenta le informazioni di richiesta e allocazione di una subnet globale. Per saperne di più sulle risorse Subnet, consulta Gestisci le subnet.
    • PORT: la porta da esporre nella regola di forwarding. Utilizza il campo ports per specificare un array di porte L4 per le quali i pacchetti vengono inoltrati ai backend configurati con questa regola di forwarding. È necessario specificare almeno una porta. Utilizza il campo port per specificare un numero di porta. La porta esposta deve essere la stessa esposta dall'applicazione effettiva all'interno del container.
    • PROTOCOL: il protocollo da utilizzare per la regola di forwarding, ad esempio TCP. Una voce nell'array ports deve avere il seguente aspetto:
    ports:
    - port: 80
      protocol: TCP
    
  5. Per convalidare l'ELB configurato, verifica la condizione Ready su ciascuno degli oggetti creati. Prova a testare il traffico con una richiesta curl al VIP.

    1. Recupera il VIP per il progetto:

      kubectl get forwardingruleexternal -n PROJECT
      

      L'output è simile al seguente:

      NAME           BACKENDSERVICE                  CIDR              READY
      elb-name       BACKEND_SERVICE_NAME            192.0.2.0/32      True
      
    2. Verifica il traffico con una richiesta curl al VIP sulla porta specificata nel campo PORT della regola di forwarding:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Sostituisci FORWARDING_RULE_VIP:PORT con il VIP e la porta della regola di forwarding, ad esempio 192.0.2.0:80.

Esegui il deployment dei workload dei container in ogni cluster di zona

I workload dei container non sono una risorsa globale, il che significa che devi eseguire il deployment di ogni applicazione container separatamente nei cluster Kubernetes di zona.

  1. Accedi alla zona che ospita il tuo cluster Kubernetes:

    gdcloud config set core/zone ZONE
    
  2. Verifica che l'immagine container sia disponibile dal registry Harbor gestito. Per saperne di più, consulta il tutorial Esegui il deployment di un'app container.

  3. Crea un file manifest per il workload del container ed eseguine il deployment nel tuo cluster Kubernetes a livello di zona:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: DEPLOYMENT_NAME
    spec:
      replicas: NUMBER_OF_REPLICAS
      selector:
        matchLabels:
          run: APP_NAME
      template:
        metadata:
          labels:
            run: APP_NAME
        spec:
          containers:
          - name: CONTAINER_NAME
            image: HARBOR_INSTANCE_URL/HARBOR_PROJECT_NAME/IMAGE:TAG
    EOF
    

    Sostituisci quanto segue:

    • KUBERNETES_CLUSTER: il file kubeconfig per il cluster Kubernetes a livello di zona in cui esegui il deployment dei workload dei container. Se non hai ancora generato un file kubeconfig per il tuo cluster Kubernetes a livello di zona, consulta Genera manualmente il file kubeconfig per i dettagli.
    • PROJECT: lo spazio dei nomi del progetto in cui eseguire il deployment dei workload del container.
    • DEPLOYMENT_NAME: il nome del deployment del container.
    • NUMBER_OF_REPLICAS: il numero di oggetti Pod replicati gestiti dal deployment.
    • APP_NAME: il nome dell'applicazione da eseguire all'interno del deployment.
    • CONTAINER_NAME: il nome del container.
    • HARBOR_INSTANCE_URL: l'URL dell'istanza Harbor, ad esempio harbor-1.org-1.zone1.google.gdc.test.. Per recuperare l'URL dell'istanza Harbor, consulta Visualizza le istanze del registry Harbor.
    • HARBOR_PROJECT_NAME: il nome del progetto Harbor, ad esempio my-project.
    • IMAGE: il nome dell'immagine, ad esempio nginx.
    • TAG: il tag della versione dell'immagine di cui vuoi eseguire il pull, ad esempio 1.0.
  4. Ripeti i passaggi precedenti per ogni zona del tuo universo GDC. Assicurati che l'applicazione container si trovi in ogni zona che vuoi per la tua strategia di alta affidabilità.

Esponi l'applicazione containerizzata utilizzando Kubernetes

Devi esporre l'applicazione container per consentire l'accesso da altre risorse nel tuo universo GDC.

  1. Crea una risorsa Service di type: LoadBalancer. Questa risorsa espone i pod della tua applicazione su una rete.

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: v1
    kind: Service
    metadata:
      name: SERVICE_NAME
    spec:
      selector:
        app: APP_NAME
      ports:
        - port: 80
          protocol: TCP
      type: LoadBalancer
    EOF
    

    Sostituisci quanto segue:

    • KUBERNETES_CLUSTER: il file kubeconfig per il cluster Kubernetes a livello di zona in cui esegui il deployment dei workload dei container.
    • PROJECT: lo spazio dei nomi del progetto in cui si trovano i workload dei container.
    • SERVICE_NAME: il nome del servizio del bilanciatore del carico.
    • APP_NAME: l'etichetta che hai applicato alla tua applicazione container.
  2. Crea una risorsa personalizzata NetworkPolicy per consentire tutto il traffico di rete verso lo spazio dei nomi predefinito:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
      annotations:
      name: allow-all
    spec:
      ingress:
      - from:
        - ipBlock:
            cidr: 0.0.0.0/0
      podSelector: {}
      policyTypes:
      - Ingress
    EOF
    

Esegui il provisioning dello spazio di archiviazione permanente per i tuoi pod

Devi creare una risorsa PersistentVolumeClaim (PVC) per fornire ai pod dell'applicazione l'archiviazione permanente.

Le seguenti istruzioni mostrano come creare un volume utilizzando StorageClass standard-rwo di GDC.

  1. Crea una risorsa PersistentVolumeClaim. Ad esempio, configuralo con una modalità di accesso ReadWriteOnce e una classe di archiviazione standard-rwo:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: PVC_NAME
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: standard-rwo
    EOF
    

    Sostituisci quanto segue:

    • KUBERNETES_CLUSTER: il file kubeconfig per il cluster Kubernetes.
    • PROJECT: lo spazio dei nomi del progetto in cui creare la PVC.
    • PVC_NAME: il nome dell'oggetto PersistentVolumeClaim.
  2. Il provisioning degli oggetti PersistentVolume (PV) viene eseguito dinamicamente. Controlla lo stato dei nuovi VP nel cluster Kubernetes:

    kubectl get pv --kubeconfig KUBERNETES_CLUSTER
    

    L'output è simile al seguente:

    NAME       CAPACITY   ACCESS MODES   STATUS      CLAIM     STORAGECLASS   AGE
    pvc-uuidd  10Gi       RWO            Bound       pvc-name  standard-rwo   60s
    
  3. Configura i workload dei container in modo che utilizzino la PVC. Di seguito è riportato un esempio di manifest del pod che utilizza una PVC standard-rwo:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: apps/v1
    kind: Pod
    metadata:
      name: web-server-deployment
      labels:
        app: APP_LABEL
    spec:
      containers:
      - name: CONTAINER_NAME
        image: HARBOR_INSTANCE_URL/HARBOR_PROJECT_NAME/IMAGE:TAG
        volumeMounts:
        - mountPath: MOUNT_PATH
          name: data
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: PVC_NAME
    EOF
    

    Sostituisci quanto segue:

    • KUBERNETES_CLUSTER: il file kubeconfig per il cluster Kubernetes su cui stai distribuendo i carichi di lavoro dei container.
    • PROJECT: lo spazio dei nomi del progetto in cui si trova la PVC.
    • APP_LABEL: l'etichetta che hai applicato alla tua applicazione container.
    • CONTAINER_NAME: il nome del container.
    • HARBOR_INSTANCE_URL: l'URL dell'istanza Harbor, ad esempio harbor-1.org-1.zone1.google.gdc.test.. Per recuperare l'URL dell'istanza Harbor, consulta Visualizza le istanze del registry Harbor.
    • HARBOR_PROJECT_NAME: il nome del progetto Harbor, ad esempio my-project.
    • IMAGE: il nome dell'immagine, ad esempio nginx.
    • TAG: il tag della versione dell'immagine di cui vuoi eseguire il pull, ad esempio 1.0.
    • MOUNT_PATH: il percorso all'interno del pod in cui montare il volume.
    • PVC_NAME: la PVC che hai creato.

Configura la replica dello spazio di archiviazione

Gli universi multizona di GDC supportano la replica dello spazio di archiviazione per il ripristino di emergenza. Questa strategia fornisce la replica dei dati tra due zone qualsiasi nella stessa regione, garantendo che i dati dell'applicazione rimangano accessibili anche se una zona non è più disponibile.

Scegli uno dei seguenti tipi di replica dello spazio di archiviazione per la tua applicazione container:

Crea un bucket dual-region per l'archiviazione di oggetti

I dati di archiviazione di oggetti vengono scritti in un singolo bucket i cui dati sono archiviati in entrambe le zone. A differenza della replica dei volumi, i bucket replicati sono scrivibili durante le partizioni delle zone. Ogni scrittura su un oggetto produce una versione diversa e l'ultima versione in una delle due zone sarà lo stato finale dopo il ripristino della connettività.

  1. Verifica che l'operatore dell'infrastruttura (IO) abbia creato la risorsa personalizzata BucketLocationConfig, necessaria per la replica tra zone per l'archiviazione di oggetti. Il deployment di questa risorsa deve essere eseguito sul server API globale principale.

  2. Crea la risorsa personalizzata Bucket a due zone:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: object.global.gdc.goog/v1
    kind: Bucket
    metadata:
      name: BUCKET_NAME
      namespace: PROJECT
    spec:
      location: LOCATION_NAME
      description: Sample DZ Bucket
      storageClass: Standard
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il file kubeconfig per il server API globale.
    • BUCKET_NAME: il nome del bucket di archiviazione.
    • PROJECT: il nome del progetto in cui si trova il bucket.
    • LOCATION_NAME: il luogo fisico in cui si trovano i dati degli oggetti nel bucket. Deve essere mappato al nome di una risorsa BucketLocation esistente. Per eseguire una query sul server API globale della tua organizzazione per un elenco di risorse BucketLocation disponibili, esegui kubectl --kubeconfig GLOBAL_API_SERVER bucketlocations. Se non sono presenti risorse BucketLocation, contatta il tuo IO per verificare che abbia attivato la replica.

Configura la replica asincrona dell'archiviazione a blocchi tra zone

L'archiviazione a blocchi replicata fornisce volumi replicati in modo asincrono (PV), che mantengono l'equivalenza dei blocchi tra i volumi primari e secondari. A causa della natura asincrona, il volume secondario riflette lo stato della zona principale in un momento passato (RPO diverso da zero). Il volume secondario non è montabile finché rimane la destinazione della replica, il che richiede un intervento manuale per terminare la relazione e consentire le scritture.

Devi configurare una relazione di replica dello spazio di archiviazione tra zone per creare dati replicati disponibili per il failover se i dati della zona di origine diventano non disponibili. Questo è importante se utilizzi l'archiviazione a blocchi per la tua applicazione container.

Prima di iniziare, verifica che l'operatore di infrastruttura (IO) abbia creato e configurato le risorse personalizzate StorageClusterPeering e StorageVirtualMachinePeering per consentire la replica dell'archiviazione a blocchi tra le zone. Il deployment di questa risorsa deve essere eseguito sul server API globale principale.

  1. Crea un file YAML della risorsa personalizzata VolumeReplicationRelationship ed eseguine il deployment nel server API globale:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: storage.global.gdc.goog/v1
    kind: VolumeReplicationRelationship
    metadata:
      name: PVC_REPL_NAME
      namespace: PROJECT
    spec:
      source:
        pvc:
          clusterRef: SOURCE_PVC_CLUSTER
          pvcRef: SOURCE_PVC
        zoneRef: SOURCE_ZONE
    destination:
        pvc:
          clusterRef: DEST_PVC_CLUSTER
        zoneRef: DEST_ZONE
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il file kubeconfig per il server API globale.
    • PVC_REPL_NAME: il nome della relazione di replica del volume.
    • PROJECT: il progetto in cui si trova l'infrastruttura di archiviazione.
    • SOURCE_PVC_CLUSTER: il cluster Kubernetes in cui è ospitata la PVC.
    • SOURCE_PVC: il PVC nella zona di origine da replicare.
    • SOURCE_ZONE: la zona di origine in cui è ospitato il PVC.
    • DEST_PVC_CLUSTER: il cluster Kubernetes di destinazione in cui replicare la PVC.
    • DEST_ZONE: la zona di destinazione in cui replicare il PVC.
  2. Crea una risorsa personalizzata VolumeFailover nella zona di destinazione, che interrompe la replica nella zona di destinazione se la zona di origine non è disponibile per qualsiasi motivo:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: storage.gdc.goog/v1
    kind: VolumeFailover
    metadata:
      name: PVC_FAILOVER_NAME
      namespace: PROJECT
    spec:
      volumeReplicationRelationshipRef: PVC_REPL_NAME
    EOF
    

    Sostituisci quanto segue:

    • MANAGEMENT_API_SERVER: il file kubeconfig del server API di gestione di zona.
    • PVC_FAILOVER_NAME: il nome del PVC di failover.
    • PROJECT: il progetto in cui si trova l'infrastruttura di archiviazione.
    • PVC_REPL_NAME: il nome della relazione di replica del volume.

Passaggi successivi