Gestisci le macchine virtuali

Questa pagina descrive come gestire le macchine virtuali nel deployment di Google Distributed Cloud connected che esegue VM Runtime su Google Distributed Cloud. Prima di completare i passaggi di questa pagina, devi avere familiarità con VM Runtime su GDC. Per un elenco dei sistemi operativi guest supportati, vedi Sistemi operativi guest verificati per VM Runtime su GDC.

Per scoprire in che modo le macchine virtuali fungono da componente essenziale della piattaforma Distributed Cloud connected, consulta Estendere GKE Enterprise per gestire le VM edge on-premise.

I cluster Google Distributed Cloud connesso supportano i webhook delle macchine virtuali. Ciò consente a Distributed Cloud connesso di convalidare le richieste degli utenti effettuate al server API Kubernetes locale. Le richieste rifiutate generano informazioni dettagliate sul motivo del rifiuto.

Configura Symcloud Storage

Google Distributed Cloud connected utilizza Rakuten Symcloud Storage come soluzione di archiviazione. Symcloud Storage è una soluzione di terze parti che funge da livello di astrazione dell'archiviazione locale su ogni nodo Distributed Cloud connesso e rende disponibile l'archiviazione locale ai carichi di lavoro in esecuzione su altri nodi Distributed Cloud connessi.

Symcloud Storage viene implementato da Google Cloud Marketplace ed è soggetto ai termini ivi indicati. Google fornisce un supporto limitato per l'utilizzo di Symcloud Storage con Distributed Cloud connesso e potrebbe coinvolgere il fornitore di terze parti per ricevere assistenza. Gli aggiornamenti software per Symcloud Storage sono inclusi negli aggiornamenti software connessi a Distributed Cloud.

Configura il cluster connesso a Google Distributed Cloud nel seguente modo per abilitare Symcloud Storage per le macchine virtuali. Per saperne di più, vedi Installare Symcloud Storage su un nodo Distributed Cloud connesso.

1. Crea lo spazio dei nomi robin-admin con il seguente comando:

   kubectl create ns robin-admin
   

2. Ottieni il file di licenza di Symcloud Storage e applicalo al cluster con il comando seguente:

   kubectl apply LICENSE_FILE
   

3. Verifica che Symcloud Storage sia in esecuzione con questo comando:

   kubectl describe robincluster
   

   Il comando restituisce un output simile al seguente:

    Name:         robin
    Namespace:
    Labels:       app.kubernetes.io/instance=robin
                  app.kubernetes.io/managed-by=robin.io
                  app.kubernetes.io/name=robin
    Annotations:  <none>
    API Version:  manage.robin.io/v1
    Kind:         RobinCluster
    Metadata:
      …
    Spec:
      …
    Status:
      …
      Phase:             Ready
      …
   

4. Crea la classe di archiviazione robin-block-immediate applicando la seguente configurazione al cluster:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: robin-block-immediate
   parameters:
     faultdomain: host
     replication: "3"
     blocksize:   "512"
   provisioner: robin
   reclaimPolicy: Delete
   volumeBindingMode: Immediate
   allowVolumeExpansion: true
   

5. Crea la classe snapshot del volume robin-snapshotclass applicando la seguente configurazione al cluster:

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: robin-snapshotclass
     labels:
       app.kubernetes.io/instance: robin
       app.kubernetes.io/managed-by: robin.io
       app.kubernetes.io/name: robin
     annotations:
       snapshot.storage.kubernetes.io/is-default-class: "true"
   driver: robin
   deletionPolicy: Delete
   

6. Modifica storageprofile per la classe di archiviazione robin-block-immediate con i seguenti contenuti e applicala al cluster:

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: StorageProfile
   metadata:
     name: robin-block-immediate
   spec:
     claimPropertySets:
       accessModes:
         ReadWriteMany
     volumeMode: Block

Installa lo strumento di gestione virtctl

Per gestire le macchine virtuali nel cluster Distributed Cloud connesso, devi utilizzare lo strumento client virtctl. Per installare lo strumento, completa i seguenti passaggi:

1. Installa lo strumento client virtctl come plug-in kubectl:

   export VERSION=GDC_SO_VERSION
   gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
   sudo mv ./virtctl /usr/local/bin/virtctl
   cd /usr/local/bin
   sudo ln -s virtctl kubectl-virt
   sudo chmod a+x virtctl
   cd -

   Sostituisci GDC_SO_VERSION con la versione di destinazione di Distributed Cloud solo software.

2. Verifica che il plug-in virt sia installato:

   kubectl plugin list

   Se il plug-in è stato installato correttamente, l'output del comando elenca kubectl-virt tra i plug-in.

Crea un bucket Cloud Storage per le immagini VM

Completa i passaggi descritti in questa sezione per creare un bucket Cloud Storage per le immagini delle macchine virtuali. Il bucket utilizza la federazione delle identità per i carichi di lavoro per associare un account di servizio Kubernetes al service account Google Cloud corrispondente per accedere al bucket; in altre parole, il account di servizio Kubernetes simula il account di servizio account Google Cloud. Se hai già un repository di immagini consolidato, salta questa sezione.

Per ridurre il rischio di identità identiche in un parco risorse multicluster, segui le linee guida riportate in Best practice per la federazione delle identità dei carichi di lavoro del parco risorse quando completi i passaggi di questa sezione.

1. Completa i passaggi descritti in Crea bucket per creare un bucket.

2. Crea un Google Cloud service account per accedere al bucket:

   export GSA_PROJECT_ID=GSA_PROJECT_ID
   export GSA_NAME=GSA_NAME
   gcloud iam service-accounts create ${GSA_NAME}

   Sostituisci quanto segue:

   • GSA_NAME: un nome significativo per questo service account Google Cloud .
   • GSA_PROJECT_ID: l'ID del progetto Google Cloud che ospita il service account di destinazione Google Cloud .

3. Concedi all'account di servizio le autorizzazioni per accedere al bucket: Google Cloud

   export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
   export GSA_NAME=GSA_NAME
   gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
      --member="serviceAccount:${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
      --role="roles/storage.objectViewer" \
      --project=${BUCKET_PROJECT_ID}

   Sostituisci quanto segue:

   • GSA_NAME: il nome del Google Cloud service account di destinazione.
   • BUCKET_PROJECT_ID: l'ID del progetto Google Cloud che ospita il bucket.
   • GSA_PROJECT_ID: l'ID del progetto Google Cloud che ospita il service account di destinazione Google Cloud .

4. Crea un account di servizio Kubernetes nello spazio dei nomi della macchina virtuale di destinazione a cui associare il tuo service account Google Cloud :

   export GSA_PROJECT_ID=GSA_PROJECT_ID
   export VM_NAMESPACE=NAMESPACE
   export KSA_NAME=KSA_NAME
   export GSA_EMAIL=${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com
   kubectl create serviceaccount ${KSA_NAME} -n ${VM_NAMESPACE}
   kubectl annotate serviceaccount ${KSA_NAME} gsaEmail=${GSA_EMAIL} -n ${VM_NAMESPACE}

   Sostituisci quanto segue:

   • GSA_PROJECT_ID: l'ID del progetto Google Cloud che ospita il service account di destinazione Google Cloud .
   • NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
   • KSA_NAME: un nome significativo per questo account di servizio Kubernetes.
   • GSA_NAME: il nome del service account Google Cloud corrispondente.

5. Trova il nome del pool di identità del workload e del provider di identità del tuo cluster:

   gcloud container fleet memberships describe MEMBERSHIP_ID \
       --project=FLEET_PROJECT_ID \
       --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"

   Sostituisci quanto segue:

   • MEMBERSHIP_ID: il nome dell'appartenenza del parco cluster. In genere è il nome del cluster.
   • FLEET_PROJECT_ID: l'ID del progetto Google Cloud host del parco veicoli.

   Il comando restituisce un output simile al seguente:

   IDENTITY_PROVIDER: IDENTITY_PROVIDER
   WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL
   

   Nell'output, prendi nota dei seguenti valori:

   • IDENTITY_PROVIDER: il provider di identità per questo cluster.
   • WORKLOAD_IDENTITY_POOL: è il nome del pool di identità del workload associato al tuo parco progetti. Il nome ha il formato FLEET_PROJECT_ID.svc.id.goog. Per ulteriori informazioni sul comando in questo passaggio, consulta Utilizzare la federazione delle identità per i carichi di lavoro del parco risorse nelle applicazioni.

6. Associa il account di servizio Kubernetes al service account Google Cloud per configurare la rappresentazione:

   export GSA_PROJECT_ID=GSA_PROJECT_ID
   export GSA_NAME=GSA_NAME
   export KSA_NAME=KSA_NAME
   export VM_NAMESPACE=NAMESPACE
   export WI_POOL=WORKLOAD_IDENTITY_POOL
   gcloud iam service-accounts add-iam-policy-binding ${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com \
      --project=${GSA_PROJECT_ID} \
      --role=roles/iam.workloadIdentityUser \
      --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]"
      --condition="IAM_CONDITION"
      --condition-from-file="IAM_CONDITION_FILE"

   Sostituisci quanto segue:

   • GSA_PROJECT_ID: l'ID del progetto Google Cloud che ospita il service account di destinazione Google Cloud .
   • GSA_NAME: il nome del service account Google Cloud corrispondente.
   • KSA_NAME: il nome del account di servizio Kubernetes di destinazione.
   • NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
   • WORKLOAD_IDENTITY_POOL: il nome del pool di identità del workload del cluster.
   • IAM_CONDITION: facoltativo; specifica le condizioni IAM da utilizzare per limitare l'accesso a cluster specifici all'interno del parco risorse. Se omesso o impostato su None, non si applicano condizioni IAM.
   • IAM_CONDITION_FILE: facoltativo; specifica il file contenente le condizioni IAM per limitare l'accesso a cluster specifici all'interno del parco risorse. Se omesso, non vengono applicate condizioni IAM, a meno che il flag --condition non sia specificato e impostato su un valore diverso da None.

7. Archivia le immagini nel bucket.

Hai anche la possibilità di utilizzare il metodo legacy che prevede l'utilizzo di un segreto generato dalla chiave attiva dell'account di servizio Google. Per saperne di più, consulta Crea un bucket Cloud Storage per le immagini delle macchine virtuali.

Limitare l'accesso al bucket con le condizioni IAM

Le condizioni IAM ti consentono di specificare quali cluster nel parco risorse possono accedere al bucket. Se non vengono specificate condizioni IAM, tutti i cluster nel parco risorse con lo stesso account di servizio Kubernetes nello stesso spazio dei nomi possono accedere al bucket, il che comporta un rischio di identità identica. Se non specifichi le condizioni IAM, puoi anche ripristinare il meccanismo di accesso legacy che utilizza un secret generato dalla chiave attiva di un account di servizio Google. Di seguito è riportato un esempio di come configurare e applicare le condizioni IAM per limitare l'accesso al bucket:

1. Crea il file di condizione IAM:

   cat <<EOF > iam_condition.yaml
   > expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
   title: allow_only_this_cluster
   > EOF

2. Applica il file delle condizioni IAM quando associ il GSA al KSA. Esegui questo comando nel tuo progetto GSA Google Cloud :

   gcloud iam service-accounts add-iam-policy-binding "${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
     --project="${GSA_PROJECT_ID}" \
     --role=roles/iam.workloadIdentityUser \
     --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]" \
     --condition-from-file=iam_condition.yaml

Crea un disco della macchina virtuale da un'immagine della macchina virtuale

Completa i passaggi descritti in questa sezione per creare un disco della macchina virtuale da un'immagine della macchina virtuale.

Crea un disco da un'immagine archiviata in Cloud Storage

Crea un disco della macchina virtuale da una macchina virtuale archiviata nel bucket Cloud Storage applicando la seguente configurazione al cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KSA_NAME
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Sostituisci quanto segue:

• DISK_NAME: il nome del disco della macchina virtuale.
• NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
• IMAGE_FILE_PATH: il percorso completo e il nome del file immagine della macchina virtuale. Fai clic con il tasto destro del mouse sull'immagine nella console Google Cloud e seleziona Copia URI gsutil per ottenere questo percorso.
• KSA_NAME: il account di servizio Kubernetes per scaricare le immagini delle macchine virtuali create in precedenza.
• DISK_SIZE: le dimensioni del disco di destinazione. Questo valore deve essere maggiore del valore virtual-size del file immagine della macchina virtuale. Puoi trovare questo valore con il comando qemu-img info DISK_SIZE.

Se non specifichi un valore storageClassName, viene utilizzato il valore predefinito specificato nella risorsa VMRuntime.

Crea un disco da un'immagine archiviata su un servizio di terze parti

Puoi anche utilizzare http, https, S3 o un registro di immagini per archiviare le immagini delle macchine virtuali. Se il tuo servizio di archiviazione richiede credenziali per l'accesso, convertile in un secret e specificalo utilizzando il campo secretRef. Ad esempio:

source:
    http/s3/registry:
       url: 
       secretRef: "SECRET_NAME" # optional

Sostituisci SECRET_NAME con il nome del tuo secret.

Per saperne di più, consulta Origine HTTP/S3/GCS/Registro.

Crea un disco vuoto

Crea un disco della macchina virtuale vuoto applicando la seguente configurazione al cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Sostituisci quanto segue:

• DISK_NAME: il nome del disco della macchina virtuale.
• NAMESPACE: lo spazio dei nomi di destinazione.
• DISK_SIZE: le dimensioni del disco desiderate in gibibyte. Questo valore deve essere maggiore del valore virtual-size del file immagine della macchina virtuale. Puoi trovare questo valore con il comando qemu-img info DISK_SIZE.

Se non specifichi un valore storageClassName, viene utilizzato il valore predefinito specificato nella risorsa VMRuntime.

Configura il networking virtuale

Segui i passaggi descritti in Networking per configurare il networking virtuale per le tue macchine virtuali.

Creare una macchina virtuale

Completa i passaggi descritti in questa sezione per creare una macchina virtuale nel deployment del server connesso a Distributed Cloud. Le istruzioni in questa sezione sono esempi pensati per illustrare le configurazioni per diversi scenari. Per informazioni dettagliate sulla configurazione delle macchine virtuali, consulta Crea una VM con risorse CPU e di memoria specifiche utilizzando VM Runtime su GDC.

Crea una macchina virtuale utilizzando la console Google Cloud

Per creare una macchina virtuale utilizzando la console Google Cloud :

1. Nella console Google Cloud , vai alla pagina Cluster.

   Vai a Cluster

2. Seleziona il progetto Google Cloud di destinazione.

3. (Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:

   1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.

   2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.

   3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.

   4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione preferito, inserisci le tue credenziali e fai clic su ACCEDI.

4. Vai alla pagina Macchine virtuali.

   Vai a Macchine virtuali

5. Fai clic su CREA.

6. Nella sezione Nozioni di base, segui questi passaggi:

   1. Nel campo Nome, inserisci un nome significativo per la macchina virtuale.

   2. Nel campo Seleziona cluster, seleziona il cluster di destinazione per la macchina virtuale.

   3. Nel campo Spazio dei nomi, seleziona lo spazio dei nomi di destinazione.

   4. Nel campo Tipo di sistema operativo, seleziona il sistema operativo di destinazione.

   5. (Facoltativo) Se vuoi aggiungere una o più etichette alla configurazione di questa macchina virtuale, fai clic su AGGIUNGI ETICHETTA.

7. Nella sezione Configurazione macchina, esegui una delle seguenti operazioni:

   • Se vuoi specificare il numero di vCPU e la quantità di memoria per questa macchina virtuale, seleziona Configurazione personalizzata e inserisci i valori target, poi fai clic su AVANTI.

   • Se vuoi utilizzare un numero predeterminato di vCPU e una quantità di memoria per questa macchina virtuale, seleziona Configurazione standard e seleziona una configurazione della macchina dall'elenco a discesa Tipo di macchina, poi fai clic su AVANTI.

8. Nella sezione Spazio di archiviazione, esegui una delle seguenti operazioni:

   • Se vuoi creare un nuovo disco virtuale per questa macchina virtuale, seleziona Aggiungi un nuovo disco e inserisci un nome significativo nel campo Nome, una dimensione in gigabyte nel campo GiB e un URL nel campo Immagine.

   • Se vuoi utilizzare un disco virtuale esistente per questa macchina virtuale, seleziona Seleziona un disco esistente e seleziona l'immagine disco di destinazione dall'elenco a discesa Seleziona un disco.

   • Specifica se vuoi che il disco sia di sola lettura e se verrà eliminato automaticamente quando questa macchina virtuale viene eliminata utilizzando le caselle di controllo Sola lettura ed Eliminazione automatica.

   • Specifica un driver del disco virtuale nell'elenco a discesa Driver.

   • Per aggiungere un altro disco a questa macchina virtuale, fai clic su AGGIUNGI UN DISCO nella sezione Dischi aggiuntivi.

   • Fai clic su AVANTI.

9. Nella sezione Rete, segui questi passaggi:

   1. Nella sottosezione Interfaccia di rete predefinita, specifica il nome dell'interfaccia di rete principale per questa macchina virtuale nel campo Nome interfaccia.

   2. Seleziona il tipo di rete corrispondente dall'elenco a discesa Tipo di rete.

   3. Specifica se consentire l'accesso esterno a questa interfaccia di rete utilizzando la casella di controllo Consenti accesso esterno. Se attivi questa opzione, devi inserire un elenco separato da virgole di porte da esporre esternamente nel campo Porte esposte.

   4. Se vuoi aggiungere una o più interfacce di rete secondarie a questa macchina virtuale, fai clic su AGGIUNGI UN'INTERFACCIA DI RETE.

   5. Fai clic su AVANTI.

10. Nella sezione Opzioni avanzate, utilizza la casella di controllo Riavvio automatico all'aggiornamento per specificare se riavviare questa macchina virtuale dopo l'aggiornamento del software connesso a Distributed Cloud nel cluster di destinazione.
    

11. Nella sezione Firmware, segui questi passaggi:

    1. Seleziona il tipo di firmware di destinazione nel campo Tipo di bootloader. Se selezioni il firmware UEFI, hai la possibilità di abilitare l'avvio protetto utilizzando la casella di controllo Avvio protetto.

    2. Specifica un numero di serie per questa macchina virtuale nel campo Seriale.

    3. Specifica un UUID (Universally Unique Identifier) per questa macchina virtuale nel campo UUID.

12. Nella sezione Cloud-init, segui questi passaggi:

    • Specifica un valore del secret dei dati di rete nel campo Secret dei dati di rete.

    • Specifica un valore segreto dei dati utente nel campo Segreto dei dati utente.

13. Fai clic su CREA VM per creare la macchina virtuale.

Crea una macchina virtuale da un file YAML

Per creare una macchina virtuale da un file di configurazione YAML:

1. Nella console Google Cloud , vai alla pagina Cluster.

   Vai a Cluster

2. Seleziona il progetto Google Cloud di destinazione.

3. (Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:

   1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.

   2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.

   3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.

   4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione preferito, inserisci le tue credenziali e fai clic su ACCEDI.

4. Vai alla pagina Macchine virtuali.

   Vai a Macchine virtuali

5. Fai clic su CREA CON YAML.

6. Nel campo Seleziona cluster, seleziona il cluster di destinazione per la macchina virtuale.

7. Incolla la configurazione della macchina virtuale in formato YAML nel campo YAML.

8. Fai clic su CREA.

Crea una macchina virtuale da un'immagine disco avviabile

Per creare una macchina virtuale da un'immagine disco avviabile, applica la seguente configurazione al cluster:

kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: my-vm-namespace
spec:
  osType: Linux/Windows
  guestEnvironment: {} // comment out this line to enable guest environment for access management
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
      - name: eth0
        networkName: network-410
        ipAddresses:
        - 10.223.237.10/25
  disks:
    - virtualMachineDiskName: my-boot-disk
      boot: true
    - virtualMachineDiskName: my-data-disk

Sostituisci quanto segue:

• DISK_NAME: il nome del disco della macchina virtuale.
• NAMESPACE: lo spazio dei nomi di destinazione.

Crea una macchina virtuale da un'immagine del disco ottico ISO

Per creare una macchina virtuale da un'immagine disco ottico ISO, completa i passaggi descritti in Crea una VM Windows da un'immagine ISO in Google Distributed Cloud.

Crea una macchina virtuale con supporto GPU

Completa i passaggi descritti in questa pagina per creare una macchina virtuale configurata per soddisfare i requisiti della tua attività, quindi completa i passaggi descritti in Configura una macchina virtuale per utilizzare le risorse GPU.

Accedere a una macchina virtuale

Completa i passaggi descritti in questa sezione per accedere a una macchina virtuale in esecuzione nel deployment del server connesso a Distributed Cloud.

Ottenere le credenziali di accesso

Se non disponi già delle credenziali per accedere alla macchina virtuale, completa i passaggi di questa sezione per ottenerle utilizzando la funzionalità dell'ambiente guest Linux.

1. Attiva l'ambiente guest Linux per la macchina virtuale di destinazione applicando la seguente configurazione al cluster:

   kind: VirtualMachine
   metadata:
    name: my-virtual-machine
    namespace: my-vm-namespace
   spec:
    osType: Linux
    guestEnvironment: // enabled by default; disable with guestEnvironment: {}
      accessManagement:
       enable: true

2. Genera un file id_rsa.pub contenente una coppia di chiavi SSH con il seguente comando:

   ssh-keygen -t rsa

3. Crea una risorsa VirtualMachineAccessRequest applicando la seguente configurazione al cluster:

   apiVersion: vm.cluster.gke.io/v1alpha1
   kind: VirtualMachineAccessRequest
   metadata:
    name: RESOURCE_NAME
    namespace: NAMESPACE
   spec:
     vm: VM_NAME
     user: USER_NAME
     ssh:
       key: RSA_KEY
       ttl: 2h

Sostituisci quanto segue:

• RESOURCE_NAME: un nome descrittivo per questa risorsa di richiesta di accesso alla macchina virtuale.
• NAMESPACE: lo spazio dei nomi di destinazione.
• VM_NAME: il nome della macchina virtuale di destinazione.
• USER_NAME: il nome dell'utente a cui viene concesso l'accesso.
• RSA_KEY: i contenuti del file id_rsa.pub generato nel passaggio precedente.

1. Controlla lo stato della richiesta di accesso con il seguente comando:

   kubectl get vmar
   

   Quando il comando restituisce lo stato Configured, vai al passaggio successivo.

2. Accedi alla macchina virtuale con SSH o Remote Desktop:

   • Se la macchina virtuale è connessa alla tua rete locale, puoi accedervi direttamente.
   • Se la macchina virtuale è connessa alla rete del pod, devi creare un servizio di bilanciamento del carico per accedere alle porte richieste.

Avviare, riavviare o arrestare una macchina virtuale

Utilizza i seguenti comandi per avviare, riavviare o arrestare una macchina virtuale:

• Avvia una macchina virtuale: kubectl virt start vmVM_NAME-nNAMESPACE
• Riavvia una macchina virtuale: kubectl virt restart vmVM_NAME-nNAMESPACE
• Arrestare una macchina virtuale: kubectl virt stop vmVM_NAME-nNAMESPACE

Sostituisci quanto segue:

• VM_NAME: il nome della macchina virtuale di destinazione.
• NAMESPACE: lo spazio dei nomi di destinazione.

Avviare o arrestare una macchina virtuale utilizzando la console Google Cloud

1. Nella console Google Cloud , vai alla pagina Cluster.

   Vai a Cluster

2. Seleziona il progetto Google Cloud di destinazione.

3. (Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:

   1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.

   2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.

   3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.

   4. Nella finestra di dialogo visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.

4. Vai alla pagina Macchine virtuali.

   Vai a Macchine virtuali

5. Nell'elenco delle macchine virtuali, seleziona le caselle di controllo per le macchine virtuali di destinazione.

6. Nella parte superiore della pagina, fai clic su AVVIA o INTERROMPI, a seconda dei casi.

Visualizzare lo stato di una macchina virtuale utilizzando la console Google Cloud

1. Nella console Google Cloud , vai alla pagina Cluster.

   Vai a Cluster

2. Seleziona il progetto Google Cloud di destinazione.

3. (Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:

   1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.

   2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.

   3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.

   4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione preferito, inserisci le tue credenziali e fai clic su ACCEDI.

4. Vai alla pagina Macchine virtuali.

   Vai a Macchine virtuali

5. Fai clic sulla macchina virtuale di destinazione.

6. Nella pagina visualizzata, fai clic sulle schede Dettagli, Eventi e YAML per visualizzare le informazioni corrispondenti su questa macchina virtuale.

Modificare una macchina virtuale

Per modificare una macchina virtuale, devi eliminarla e ricrearla con la configurazione aggiornata.

Eliminare una macchina virtuale utilizzando la console Google Cloud

1. Nella console Google Cloud , vai alla pagina Cluster.

   Vai a Cluster

2. Seleziona il progetto Google Cloud di destinazione.

3. (Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:

   1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.

   2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.

   3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.

   4. Nella finestra di dialogo visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.

4. vai alla pagina Macchine virtuali.

   Vai a Macchine virtuali

5. Nell'elenco delle macchine virtuali, seleziona la casella di controllo della macchina virtuale di destinazione.

6. Nella parte superiore della pagina, fai clic su ELIMINA.

7. Nella finestra di dialogo di conferma visualizzata, inserisci il nome della macchina virtuale e fai clic su ELIMINA.

Eseguire il backup di una macchina virtuale

Questa sezione descrive come configurare l'ambiente per il backup dei carichi di lavoro delle macchine virtuali e come gestire i backup. Per attivare questa funzionalità, contatta il tuo rappresentante di Google.

Prerequisiti

1. Se non l'hai ancora fatto, crea la risorsa personalizzata robin-block-immediate di tipo StorageClass con i seguenti contenuti e applicala al cluster:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
    name: robin-block-immediate
    annotations:
      storageclass.kubernetes.io/is-default-class: "true"
   parameters:
    faultdomain: host
    replication: "3"
    blocksize:   "512"
   provisioner: robin
   reclaimPolicy: Delete
   volumeBindingMode: Immediate

2. Se non l'hai ancora fatto, crea una risorsa personalizzata robin-snapshotclass di tipo VolumeSnapshotClass con i seguenti contenuti e applicala al tuo cluster:

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
    name: robin-snapshotclass
    labels:
      app.kubernetes.io/instance: robin
      app.kubernetes.io/managed-by: robin.io
      app.kubernetes.io/name: robin
    annotations:
      snapshot.storage.kubernetes.io/is-default-class: "true"
   driver: robin
   deletionPolicy: Delete

Crea un repository di backup online

Un repository di backup online è una posizione di archiviazione online compatibile con S3 per i backup delle macchine virtuali. Inoltre, memorizza i record di backup, piani di backup, piani di ripristino e funge da destinazione per il ripristino dei backup delle macchine virtuali.

Per creare un repository di backup online per le tue macchine virtuali:

1. Crea un bucket Cloud Storage come descritto in Creare bucket.

2. Crea un account di servizio e una chiave per accedere al bucket utilizzando i seguenti comandi:

   export PROJECT_ID=$(gcloud config get-value project)
   export SVC_ACCOUNT=backup-access
   gcloud iam service-accounts create $SVC_ACCOUNT
   gcloud projects add-iam-policy-binding $PROJECT_ID \ 
      --member="serviceAccount:${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com" \
      --role="roles/backupdr.cloudStorageOperator"
   gcloud storage hmac create  ${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com > hmac_temp_key_file
   awk 'NR==1{print "ACCESS_ID=" $NF} NR==2{print "SECRET=" $NF}' < hmac_temp_key_file > hmac_key_file

3. Configura il secret per accedere al bucket di backup utilizzando i seguenti comandi:

   source ./hmac_key_file
   kubectl create secret generic SECRET_NAME \
      --from-literal=access-key=$SECRET \
      --from-literal=access-key-id=$ACCESS_ID -n NAMESPACE
   

   Sostituisci quanto segue:

   • SECRET_NAME: un nome descrittivo per questo secret.
   • NAMESPACE: lo spazio dei nomi di destinazione.

4. Crea la risorsa BackupRepository applicando la seguente configurazione al cluster:

   apiVersion: backup.gdc.goog/v1
   kind: BackupRepository
   metadata:
     name: "REPOSITORY_NAME"
   spec:
     secretReference:
       namespace: NAMESPACE
       name: gcs-hmac-secret
     endpoint: "https://storage.googleapis.com"
     type: "S3"
     s3Options:
       bucket: "BUCKET_NAME"
       region: "REGION"
       forcePathStyle: true
     importPolicy: "ReadWrite"
   # Force attachment for convenience.
   force: true

   Sostituisci quanto segue:

   • REPOSITORY_NAME: un nome descrittivo per il repository.
   • BUCKET_NAME: il nome del bucket di backup.
   • NAMESPACE: lo spazio dei nomi di destinazione.
   • REGION: la Google Cloud regione in cui è stato creato il cluster Distributed Cloud di destinazione.

5. Verifica che il cluster possa accedere al repository di backup utilizzando questo comando:

   kubectl get BackupRepository
   

Crea un repository di backup locale

Un repository di backup locale è una posizione di archiviazione compatibile con S3 per i backup delle macchine virtuali che si trova localmente nel cluster connesso a Distributed Cloud. Un repository di backup locale è funzionalmente identico a un repository di backup online.

1. Genera una chiave di crittografia AES256 da utilizzare per la crittografia della configurazione a livello di applicazione:

   openssl rand -base64 32
   

   Il comando restituisce una chiave casuale a 256 bit con codifica base64. Ad esempio:

   aBcD_eFgH1iJkLmN0pQrStUvWxFyZgAhIjKlMnOpQ=
   

2. Esegui la doppia codifica della chiave da utilizzare come payload nella configurazione YAML per la risorsa BackupRepository:

   echo -n "AES_KEY" | base64
   

   Sostituisci AES_KEY con la chiave AES256 codificata in base64 che hai generato nel passaggio precedente. Archivia questa chiave in un file locale.

3. Configura il secret per accedere al repository di backup utilizzando i seguenti comandi:

   kubectl create secret generic SECRET_NAME \
      --from-literal=access-key=ENCODED_AES_KEY \
      --namespace NAMESPACE
   

   Sostituisci quanto segue:

   • ENCODED_AES_KEY: la chiave AES256 con doppia codifica generata nel passaggio precedente.
   • SECRET_NAME: un nome descrittivo per questo secret.
   • NAMESPACE: lo spazio dei nomi di destinazione.

4. Configura BackupRepository applicando la seguente configurazione al cluster:

   apiVersion: backup.gdc.goog/v1
   kind: BackupRepository
   metadata:
     name: REPOSITORY_NAME
   spec:
     force: true
     importPolicy: ReadWrite
     localOptions:
       encryptionKey:
         name: SECRET_NAME
         namespace: NAMESPACE
     type: Local

5. Verifica che il cluster possa accedere al repository di backup utilizzando questo comando:

   kubectl get BackupRepository
   

   Sostituisci quanto segue:

   • REPOSITORY_NAME: un nome descrittivo per il repository.
   • SECRET_NAME: il nome del secret Kubernetes creato nel passaggio precedente.
   • NAMESPACE: lo spazio dei nomi in cui hai creato il secret Kubernetes.

Crea un piano di backup

Un piano di backup definisce la pianificazione automatica per l'esecuzione del backup della macchina virtuale. Crea una risorsa VirtualMachineBackupPlan con i seguenti contenuti e applicala al cluster:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlan
metadata:
  name: BACKUP_PLAN_NAME
  namespace: NAMESPACE
spec:
  backupConfig:
    backupRepository: REPOSITORY_NAME
    backupScope:
      selectedVirtualMachines:
      - resourceName: VM_NAME
    volumeStrategy: LocalSnapshotOnly
  backupSchedule:
    cronSchedule: "CRON_SCHEDULE"
    paused: PAUSED
  retentionPolicy:
    backupDeleteLockDays: PLAN_LOCK_LENGTH
    backupRetainDays: 4
    locked: RETENTION_POLICY_LOCKED
  numBackupsToRetain: BACKUPS_RETAINED

Sostituisci quanto segue:

• BACKUP_PLAN_NAME: un nome descrittivo per il piano di backup.
• NAMESPACE: il nome dello spazio dei nomi di destinazione.
• REPOSITORY_NAME: il repository di backup di destinazione.
• CRON_SCHEDULE: pianificazione standard cron per l'esecuzione dei backup. L'intervallo minimo consentito tra i backup è di 10 minuti.
• PAUSED: specifica se questo piano di backup è in pausa. I valori validi sono true e false.
• VM_NAME: specifica un workload della macchina virtuale di cui eseguire il backup tramite questo piano di backup. Puoi specificare più risorse di macchine virtuali per piano di backup.
• * BACKUP_LOCK_LENGTH: specifica il numero di giorni dopo la creazione del backup durante i quali il backup non può essere eliminato.
• * BACKUP_RETENTION_LENGTH: specifica il numero di giorni per conservare questo backup. Al termine del periodo di conservazione, il backup viene eliminato. Se omesso, il valore predefinito è 4.
• * RETENTION_POLICY_LOCKED: specifica se il criterio di conservazione di questo piano di backup è bloccato. I valori validi sono true e false.
• * BACKUPS_RETAINED/var>: specifica il numero di backup da conservare in questo piano di backup. Quando viene raggiunta questa soglia, i backup vengono eliminati in ordine dal meno recente al più recente.

Elenca i piani di backup esistenti

Per elencare i piani di backup esistenti, utilizza il comando seguente:

kubectl get VirtualMachineBackupPlans -A

Il comando restituisce un output simile al seguente:

NAMESPACE      NAME                                LASTBACKUPTIME   LASTBACKUPSTATE   NEXTBACKUPTIME   PAUSED
vm-workloads   bkp-template-vm-windows-vm-local
vm-workloads   sched-snapshotonly-bkp-plan-10min                                                       false

Crea un backup manuale di una macchina virtuale

Completa i passaggi descritti in questa sezione per creare un backup manuale di una macchina virtuale.

1. Crea una risorsa VirtualMachineBackupPlanTemplate nello spazio dei nomi in cui si trova la macchina virtuale di destinazione applicando la seguente configurazione al cluster:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineBackupPlanTemplate
   metadata:
     name: TEMPLATE_NAME
     namespace: NAMESPACE
   spec:
     backupRepository: REPOSITORY_NAME

   Sostituisci quanto segue:

   • TEMPLATE_NAME: un nome descrittivo per questo modello di backup.
   • REPOSITORY_NAME: il nome del repository di backup di destinazione.
   • NAMESPACE: lo spazio dei nomi di destinazione.

2. Attiva il backup creando una risorsa VirtualMachineBackupRequest con la seguente configurazione e applicandola al cluster:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineBackupRequest
   metadata:
     name: BACKUP_REQUEST_NAME
     namespace: NAMESPACE
   spec:
     vmBackupPlanTemplate: TEMPLATE_NAME
     virtualMachine: VM_NAME
     vmBackupName: BACKUP_NAME

   Sostituisci quanto segue:

   • BACKUP_REQUEST_NAME: un nome descrittivo per questa richiesta di backup.
   • TEMPLATE_NAME: il nome del modello di backup creato nel passaggio precedente.
   • NAMESPACE: il nome dello spazio dei nomi di destinazione.
   • VM_NAME: il nome della macchina virtuale di destinazione.
   • BACKUP_NAME: un nome descrittivo per questo backup.

3. Verifica l'integrità del backup con il seguente comando:

   kubectl get vmbackup BACKUP_NAME -n NAMESPACE
   

   Sostituisci quanto segue:

   • BACKUP_NAME: il nome del backup di destinazione.
   • NAMESPACE: lo spazio dei nomi di destinazione.

   Il comando restituisce un output simile al seguente:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineBackup
   metadata:
     creationTimestamp: "2024-04-09T17:57:44Z"
     finalizers:
     - vm.cluster.gke.io/virtual-machine-backup-finalizer
     generation: 1
     name: vmt13-backup-0409-2
     namespace: default
     ownerReferences:
     - apiVersion: backup.gdc.goog/v1
       kind: Backup
       name: vmt13-backup-0409-2
       uid: 0ee0b92c-1e27-48cc-8f8f-5606ea925e88
     resourceVersion: "36192759"
     uid: e471f8c7-637c-485f-acda-108017a5638f
   spec:
     backupConfig:
       backupRepository: default
       backupScope:
         selectedVirtualMachines:
         - resourceName: vm-t13
       volumeStrategy: Portable
     vmBackupPlan: MyVmPlan-vm-vm-t13-portable
   status:
     backedUpVirtualMachineDisks:
     - vm-t13-boot-disk
     - vm-t13-data-disk
     backedUpVirtualMachines:
     - vm-t13
     backup: vmt13-backup-0409-2
     backupStatus:
       clusterMetadata:
         k8sVersion: "1.28"
       completeTime: "2024-04-09T18:07:36Z"
       createTime: "2024-04-09T17:57:44Z"
       jobCreated: true
       resourceCount: 849
       sizeBytes: 1948672
       state: Succeeded
   

Elenca i backup delle macchine virtuali

Per visualizzare i backup delle macchine virtuali esistenti, utilizza il seguente comando:

kubectl get VirtualMachineBackups -A

Il comando restituisce un output simile al seguente:

NAMESPACE      NAME        STATE       CREATETIME
vm-workloads   vm-backup   Succeeded   2025-04-08T04:37:32Z

Ripristina una macchina virtuale da un backup

Completa i passaggi descritti in questa sezione per ripristinare una macchina virtuale da un backup.

1. Attiva la procedura di ripristino creando una risorsa VirtualMachineRestoreRequest con la seguente configurazione e applicandola al cluster:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineRestoreRequest
   metadata:
     name: restore-req
     namespace: NAMESPACE
   spec:
     vmBackup: BACKUP_NAME
     restoreName: RESTORE_NAME
     restoredResourceName: RESTORED_VM_NAME
     restoredResourceDescription: RESTORE_DESCRIPTION

   Sostituisci quanto segue:

   • BACKUP_NAME: il nome del backup di destinazione.
   • RESTORE_NAME: un nome descrittivo per questa operazione di ripristino.
   • NAMESPACE: lo spazio dei nomi di destinazione.
   • RESTORED_VM_NAME: il nome assegnato alla macchina virtuale durante il ripristino. Questo nome non deve essere in conflitto con le macchine virtuali già presenti nel cluster.
   • RESTORE_DESCRIPTION: una descrizione per questa operazione di ripristino.

2. Utilizza il seguente comando per controllare l'avanzamento dell'operazione di ripristino:

   kubectl get virtualmachinerestores.vm.cluster.gke.io RESTORE_NAME -n NAMESPACE
   

   Sostituisci quanto segue:

   • RESTORE_NAME: il nome dell'operazione di ripristino di destinazione.
   • NAMESPACE: lo spazio dei nomi di destinazione.

   Il comando restituisce un output simile al seguente:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineRestore
   metadata:
     creationTimestamp: "2024-04-09T18:09:51Z"
     finalizers:
     - vm.cluster.gke.io/virtual-machine-restore-finalizer
     generation: 1
     name: vmt13-restore-0409-2-1
     namespace: default
     ownerReferences:
     - apiVersion: backup.gdc.goog/v1
       kind: Restore
       name: vmt13-restore-0409-2-1
       uid: 4ce1ca83-eba0-4cc3-bad3-af6cf9185d7d
     resourceVersion: "36194596"
     uid: aba50b59-e18d-4687-ad11-47baa45478b4
   spec:
     targetVirtualMachineDisks:
     - vm-t13-boot-disk
     - vm-t13-data-disk
     targetVirtualMachines:
     - vm-t13
     vmBackup: vmt13-backup-0409-2
   status:
     restore: vmt13-restore-0409-2-1
     restoreStatus:
       completeTime: "2024-04-09T18:10:00Z"
       jobCreated: true
       resourcesRestoredCount: 5
       restoredVolumesCount: 2
       startTime: "2024-04-09T18:09:51Z"
       state: Succeeded
       stateReason: restore is successful
   

Visualizzare le operazioni di ripristino

Per visualizzare le operazioni di ripristino avviate fino a oggi, utilizza il seguente comando:

kubectl get VirtualMachineRestore.vm.cluster.gke.io -A

Il comando restituisce un output simile al seguente:

NAMESPACE      NAME        STARTTIME              RESTORE     STATE
vm-workloads   restore-1   2025-04-08T04:41:04Z   restore-1   Succeeded

Eliminare il backup di una macchina virtuale

Per eliminare un backup della macchina virtuale, crea una risorsa VirtualMachineDeleteBackupRequest con la seguente configurazione e applicala al cluster:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineDeleteBackupRequest
    metadata:
      name: vmdbr
      namespace: BACKUP_NAME
    spec:
      vmBackup: NAMESPACE
   

Sostituisci quanto segue:

• NAMESPACE: il nome dello spazio dei nomi di destinazione.
• BACKUP_NAME: il nome del backup di destinazione.

Visualizza audit log del sandboxing di AppArmor

Distributed Cloud connected esegue automaticamente il sandbox dei carichi di lavoro delle macchine virtuali con i criteri AppArmor in audit-mode. Una violazione dei criteri genera una voce di audit log. Ad esempio:

{
  "jsonPayload": {
    "_SOURCE_REALTIME_TIMESTAMP": "1734596844149104",
    "SYSLOG_TIMESTAMP": "Dec 19 08:27:24 ",
    "MESSAGE": "type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"",
    "PRIORITY": "6",
    ...
    "SYSLOG_RAW": "<14>Dec 19 08:27:24 audisp-syslog: type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"\n",
    "SYSLOG_IDENTIFIER": "audisp-syslog",
    "_GID": "0",
  },
  "timestamp": "2024-12-19T08:27:24.149109Z",
  "labels": {
    "gke.googleapis.com/log_type": "system"
  },
  "receiveTimestamp": "2024-12-19T08:27:24.721842807Z"
  ...
  ...
}

Passaggi successivi

• Esegui il deployment dei carichi di lavoro su Distributed Cloud connected
• Gestisci i workload GPU
• Gestire le zone
• Gestisci macchine
• Gestire i cluster
• Gestisci i pool di nodi