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

Questo documento descrive come eseguire il deployment di un'applicazione di macchina virtuale (VM) 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 disastro locale.

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

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

Obiettivi

  • Crea un'istanza VM con dischi di avvio collegati in due o più zone nel tuo universo GDC.
  • Configura il bilanciamento del carico globale.
  • 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:

  • Virtual Machine Project Admin (project-vm-admin): crea e modifica le VM in uno spazio dei nomi del progetto.
  • Project Network Policy Admin (global-project-networkpolicy-admin): crea e modifica le policy di rete del progetto in tutte le zone.
  • Amministratore bilanciatore del carico globale (global-load-balancer-admin): crea e modifica i bilanciatori del carico globali.
  • 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 air-gapped:

Crea un'istanza VM in più zone

Per creare un'applicazione VM ad alta affidabilità, devi creare un'istanza VM separata in ogni zona del tuo universo GDC.

I passaggi seguenti utilizzano un'immagine sistema operativo fornita da GDC e collegano un disco di avvio alla VM. Per saperne di più sulla creazione di istanze VM e sull'utilizzo di immagini personalizzate, consulta Crea e avvia una VM.

Per impostazione predefinita, tutti i progetti GDC possono creare VM da immagini sistema operativo fornite da GDC.

Console

  1. Nel menu di navigazione, seleziona Macchine virtuali > Istanze.
  2. Fai clic su Crea istanza.
  3. Nel campo Nome, inserisci un nome per la VM.
  4. Seleziona la zona in cui creare la VM.
  5. Fai clic su Aggiungi etichette per assegnare eventuali etichette alla VM, in modo da organizzare le istanze VM.
  6. Seleziona la configurazione della macchina da utilizzare per la VM. Verifica che il tipo di macchina sia in linea con il tuo workload, in base ai requisiti.
  7. Fai clic su Avanti.
  8. Abilita l'accesso esterno per l'istanza VM.
  9. Fai clic su Avanti.
  10. Seleziona Aggiungi nuovo disco.
  11. Assegna un nome al disco della VM.
  12. Configura le dimensioni del disco e le impostazioni di collegamento.
  13. Fai clic su Salva.
  14. Fai clic sul pulsante Crea per creare l'istanza VM.
  15. Ripeti i passaggi precedenti per ogni zona del tuo universo GDC. Assicurati che un'istanza VM si trovi in ogni zona che vuoi per la tua strategia di alta affidabilità.

gdcloud

  1. Accedi alla zona in cui vuoi ospitare l'istanza VM:

    gdcloud config set core/zone ZONE
    
  2. Crea l'istanza della macchina virtuale nella zona utilizzando un'immagine fornita da GDC:

    gdcloud compute instances create VM_NAME \
        --machine-type=MACHINE_TYPE \
        --image=BOOT_DISK_IMAGE_NAME
        --image-project=vm-system \
        --boot-disk-size=BOOT_DISK_SIZE \
        --no-boot-disk-auto-delete=NO_BOOT_DISK_AUTO_DELETE
    

    Sostituisci quanto segue:

    • VM_NAME: il nome della nuova VM. Il nome deve contenere solo caratteri alfanumerici e trattini e non deve superare i 53 caratteri.
    • MACHINE_TYPE: il tipo di macchina predefinita per la nuova VM. Per selezionare un tipo di macchina disponibile, esegui gdcloud compute machine-types list.
    • BOOT_DISK_IMAGE_NAME: il nome dell'immagine da utilizzare per il nuovo disco di avvio della VM.
    • BOOT_DISK_SIZE: le dimensioni del disco di avvio, ad esempio 20GB. Questo valore deve essere sempre maggiore o uguale alla minimumDiskSize dell'immagine disco di avvio.
    • NO_BOOT_DISK_AUTO_DELETE: indica se il disco di avvio viene eliminato automaticamente quando viene eliminata l'istanza VM.
  3. Ripeti i passaggi precedenti per ogni zona del tuo universo GDC. Assicurati che un'istanza VM si trovi in ogni zona che vuoi per la tua strategia di alta affidabilità.

API

  1. Crea l'istanza della macchina virtuale nella zona utilizzando un'immagine fornita da GDC:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: virtualmachine.gdc.goog/v1
    kind: VirtualMachineDisk
    metadata:
      name: VM_BOOT_DISK_NAME
      namespace: PROJECT
    spec:
      source:
        image:
          name: BOOT_DISK_IMAGE_NAME
          namespace: vm-system
      size: BOOT_DISK_SIZE
    ---
    apiVersion: virtualmachine.gdc.goog/v1
    kind: VirtualMachine
    metadata:
      name: VM_NAME
      namespace: PROJECT
    spec:
      compute:
        virtualMachineType: MACHINE_TYPE
      disks:
        - virtualMachineDiskRef:
            name: VM_BOOT_DISK_NAME
          boot: true
          autoDelete: BOOT_DISK_AUTO_DELETE
    ---
    apiVersion: virtualmachine.gdc.goog/v1
    kind: VirtualMachineExternalAccess
    metadata:
      name: VM_NAME
      namespace: PROJECT
    spec:
      enabled: true
      ports:
      - name: port-80
        port: 80
        protocol: TCP
    EOF
    

    Sostituisci quanto segue:

    • MANAGEMENT_API_SERVER: il file kubeconfig del server dell'API di gestione per la zona in cui creare l'istanza VM. Se non hai ancora generato un file kubeconfig per il server API di gestione, consulta Genera manualmente il file kubeconfig per i dettagli.
    • VM_BOOT_DISK_NAME: il nome del nuovo disco di avvio della VM.
    • PROJECT: il progetto GDC per creare la VM.
    • BOOT_DISK_IMAGE_NAME: il nome dell'immagine da utilizzare per il nuovo disco di avvio della VM.
    • BOOT_DISK_SIZE: le dimensioni del disco di avvio, ad esempio 20Gi. Questo valore deve essere sempre maggiore o uguale alla minimumDiskSize dell'immagine disco di avvio.
    • VM_NAME: il nome della nuova VM. Il nome deve contenere solo caratteri alfanumerici e trattini e non deve superare i 53 caratteri.
    • MACHINE_TYPE: il tipo di macchina predefinita per la nuova VM. Per selezionare un tipo di macchina disponibile, esegui gdcloud compute machine-types list.
    • BOOT_DISK_AUTO_DELETE: indica se il disco di avvio viene eliminato automaticamente quando viene eliminata l'istanza VM.
  2. Verifica che la VM sia disponibile e attendi che mostri lo stato Running. Lo stato Running non indica che il sistema operativo è completamente pronto e accessibile.

    kubectl --kubeconfig MANAGEMENT_API_SERVER \
        get virtualmachine.virtualmachine.gdc.goog VM_NAME -n PROJECT
    

    Sostituisci VM_NAME e PROJECT con il nome e il progetto della VM.

  3. Ripeti i passaggi precedenti per ogni zona del tuo universo GDC. Assicurati che un'istanza VM si trovi in ogni zona che vuoi per la tua strategia di alta affidabilità.

Configura i bilanciatori del carico

Per distribuire il traffico tra le VM 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 di rete interno globale per i workload delle VM.

gdcloud

Crea un ILB che ha come target i workload delle VM 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 le VM per definire l'endpoint per l'ILB:

    gdcloud compute backends create BACKEND_NAME \
        --labels=LABELS \
        --project=PROJECT \
        --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 le VM utilizzare per questa risorsa di backend, ad esempio app=web.
    • PROJECT: il nome del progetto.
    • 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. Definisci un controllo di integrità globale per l'ILB:

    gdcloud compute health-checks create tcp HEALTH_CHECK_NAME \
        --check-interval=CHECK_INTERVAL \
        --healthy-threshold=HEALTHY_THRESHOLD \
        --timeout=TIMEOUT \
        --unhealthy-threshold=UNHEALTHY_THRESHOLD \
        --port=PORT \
        --global
    

    Sostituisci quanto segue:

    • HEALTH_CHECK_NAME: il nome della risorsa del controllo di integrità, ad esempio my-health-check.
    • CHECK_INTERVAL: l'intervallo di tempo in secondi dall'inizio di un probe all'inizio di quello successivo. Il valore predefinito è 5. Questo campo è facoltativo.
    • HEALTHY_THRESHOLD: il tempo di attesa prima di dichiarare l'errore. Il valore predefinito è 5. Questo campo è facoltativo.
    • TIMEOUT: il tempo in secondi da attendere prima di dichiarare l'errore. Il valore predefinito è 5. Questo campo è facoltativo.
    • UNHEALTHY_THRESHOLD: il numero di probe sequenziali che non devono riuscire affinché l'endpoint sia considerato non integro. Il valore predefinito è 2. Questo campo è facoltativo.
    • PORT: la porta su cui viene eseguito il controllo di integrità. Il valore predefinito è 80. Questo campo è facoltativo.
  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 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.
    • HEALTH_CHECK_NAME: il nome della risorsa del controllo di integrità. Questo campo è facoltativo.
  4. 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.

  5. 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 prenotato 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 della VM.
  6. 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 ILB che ha come target i workload delle VM 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 si trovano i workload delle VM:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      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.
    • APP_NAME: il nome della tua applicazione VM.

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

  2. Definisci un controllo di integrità globale per l'ILB:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: HealthCheck
    metadata:
      namespace: PROJECT
      name: HEALTH_CHECK_NAME
    spec:
      tcpHealthCheck:
        port: PORT
      timeoutSec: TIMEOUT
      checkIntervalSec: CHECK_INTERVAL
      healthyThreshold: HEALTHY_THRESHOLD
      unhealthyThreshold: UNHEALTHY_THRESHOLD
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il percorso kubeconfig del percorso kubeconfig del server API globale. Per saperne di più, consulta Passa a un contesto globale.
    • PROJECT: il nome del progetto.
    • HEALTH_CHECK_NAME: il nome della risorsa del controllo di integrità, ad esempio my-health-check.
    • PORT: la porta su cui eseguire il controllo di integrità. Il valore predefinito è 80.
    • TIMEOUT: il tempo in secondi da attendere prima di dichiarare l'errore. Il valore predefinito è 5.
    • CHECK_INTERVAL: l'intervallo di tempo in secondi dall'inizio di un probe all'inizio di quello successivo. Il valore predefinito è 5.
    • HEALTHY_THRESHOLD: il numero di probe sequenziali che devono essere superati affinché l'endpoint sia considerato integro. Il valore predefinito è 2.
    • UNHEALTHY_THRESHOLD: il numero di probe sequenziali che non devono riuscire affinché l'endpoint sia considerato non integro. Il valore predefinito è 2.
  3. 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 di zona Backend.
    • 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
      
  4. 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 prenotato 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 sulla 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'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 dagli indirizzi IP di un pool 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 delle tue VM.

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 la tua 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 bypassa 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 sulle VM 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
    

    Sostituisci quanto segue:

    • BACKEND_NAME: il nome della risorsa di backend, ad esempio my-backend.
    • LABELS: un selettore che definisce quali endpoint tra le VM utilizzare per questa risorsa di backend, ad esempio app=web.
    • PROJECT: il nome del progetto.

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

  3. Definisci un controllo di integrità globale per l'ELB:

    gdcloud compute health-checks create tcp HEALTH_CHECK_NAME \
      --check-interval=CHECK_INTERVAL \
      --healthy-threshold=HEALTHY_THRESHOLD \
      --timeout=TIMEOUT \
      --unhealthy-threshold=UNHEALTHY_THRESHOLD \
      --port=PORT \
      --global
    

    Sostituisci quanto segue:

    • HEALTH_CHECK_NAME: il nome della risorsa di controllo di integrità, ad esempio my-health-check.
    • CHECK_INTERVAL: l'intervallo di tempo in secondi dall'inizio di un probe all'inizio di quello successivo. Il valore predefinito è 5. Questo campo è facoltativo.
    • HEALTHY_THRESHOLD: il tempo di attesa prima di dichiarare l'errore. Il valore predefinito è 5. Questo campo è facoltativo.
    • TIMEOUT: il tempo in secondi da attendere prima di dichiarare l'errore. Il valore predefinito è 5. Questo campo è facoltativo.
    • UNHEALTHY_THRESHOLD: il numero di probe sequenziali che non devono riuscire affinché l'endpoint sia considerato non integro. Il valore predefinito è 2. Questo campo è facoltativo.
    • PORT: la porta su cui eseguire il controllo di integrità. Il valore predefinito è 80. Questo campo è facoltativo.
  4. 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.
  5. 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 BACKEND_ZONE \
      --project=PROJECT \
      --global
    

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

  6. 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 prenotato 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 della VM.
    • PROJECT: il nome del progetto.
  7. 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 delle VM 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 a livello di zona utilizzando l'API KRM, segui questi passaggi:

  1. Affinché i servizi ELB funzionino, devi configurare e applicare la tua 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 bypassa 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 sulle VM 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 sono posizionati i workload:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      endpointsLabels:
        matchLabels:
          app: server
    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.

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

  3. Definisci un controllo di integrità globale per l'ELB:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: HealthCheck
    metadata:
      namespace: PROJECT
      name: HEALTH_CHECK_NAME
    spec:
      tcpHealthCheck:
        port: PORT
      timeoutSec: TIMEOUT
      checkIntervalSec: CHECK_INTERVAL
      healthyThreshold: HEALTHY_THRESHOLD
      unhealthyThreshold: UNHEALTHY_THRESHOLD
    EOF
    

    Sostituisci quanto segue:

    • HEALTH_CHECK_NAME: il nome della risorsa di controllo di integrità, ad esempio my-health-check.
    • PORT: la porta su cui eseguire il controllo di integrità. Il valore predefinito è 80.
    • TIMEOUT: il tempo in secondi da attendere prima di dichiarare l'errore. Il valore predefinito è 5.
    • CHECK_INTERVAL: l'intervallo di tempo in secondi dall'inizio di un probe all'inizio di quello successivo. Il valore predefinito è 5.
    • HEALTHY_THRESHOLD: il numero di probe sequenziali che devono essere superati affinché l'endpoint sia considerato integro. Il valore predefinito è 2.
    • UNHEALTHY_THRESHOLD: il numero di probe sequenziali che non devono riuscire affinché l'endpoint sia considerato non integro. Il valore predefinito è 2.

    Poiché si tratta di un ELB globale, crea il controllo di integrità nell'API globale.

  4. 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
    
  5. 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 prenotato 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
    
  6. 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.

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 VM:

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 con l'operatore dell'infrastruttura (IO) che tutte le zone dell'universo siano online e raggiungibili.

  2. 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.

  3. Crea la risorsa personalizzata Bucket a doppia zona:

    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 l'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 interrompere la relazione e consentire le scritture.

Devi eseguire il deployment di una risorsa personalizzata VolumeReplicationRelationship nel server API globale per creare dati replicati disponibili per il failover se i dati della zona di origine non sono disponibili.

Prima di iniziare, verifica che l'operatore dell'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.

gdcloud

  1. Imposta la relazione del volume di replica asincrona tra la zona principale e le zone secondarie:

    gdcloud compute disks start-async-replication PRIMARY_DISK_NAME \
        --project PROJECT \
        --zone PRIMARY_ZONE \
        --secondary-disk SECONDARY_DISK_NAME \
        --secondary-zone SECONDARY_ZONE
    

    Sostituisci quanto segue:

    • PRIMARY_DISK_NAME: il nome del disco di origine da replicare.
    • PROJECT: il progetto GDC del disco primario.
    • PRIMARY_ZONE: la zona in cui si trova il disco primario.
    • SECONDARY_DISK_NAME: il nome del disco di destinazione su cui eseguire la replica.
    • SECONDARY_ZONE: la zona in cui deve risiedere il disco secondario.
  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: FAILOVER_NAME
      namespace: PROJECT
    spec:
      volumeReplicationRelationshipRef: REPL_NAME
    EOF
    

    Sostituisci quanto segue:

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

    Per saperne di più sulla gestione della replica asincrona per i workload delle VM, consulta Replica i volumi in modo asincrono.

API

  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: VRR_NAME
      namespace: PROJECT
    spec:
      source:
        virtualMachineDisk:
          virtualMachineDiskRef: PRIMARY_DISK_NAME
        zoneRef: PRIMARY_ZONE
      destination:
        volumeOverrideName: SECONDARY_DISK_NAME
        zoneRef: SECONDARY_ZONE
    EOF
    

    Sostituisci quanto segue:

    • GLOBAL_API_SERVER: il file kubeconfig per il server API di gestione globale.
    • VRR_NAME: il nome della relazione di replica del volume. Lo stesso nome deve essere utilizzato quando si interrompe la replica asincrona.
    • PROJECT: il progetto GDC del disco primario.
    • PRIMARY_DISK_NAME: il nome del disco di origine da replicare.
    • PRIMARY_ZONE: la zona in cui si trova il disco primario.
    • SECONDARY_DISK_NAME: il nome del disco di destinazione in cui eseguire la replica.
    • SECONDARY_ZONE: la zona in cui deve risiedere il disco secondario.
  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: FAILOVER_NAME
      namespace: PROJECT
    spec:
      volumeReplicationRelationshipRef: REPL_NAME
    EOF
    

    Sostituisci quanto segue:

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

Per saperne di più sulla gestione della replica asincrona per i workload delle VM, consulta Replica i volumi in modo asincrono.

Passaggi successivi