Tutorial: eseguire il deployment di una VM esistente in un cluster Anthos utilizzando Anthos VM Runtime

---

Version 1.13 

• Ultimi
• Versione 1.16
• Versioni precedenti (non supportate)

Questo documento fornisce una guida passo passo per eseguire il deployment di un carico di lavoro basato su macchina virtuale (VM) in Cluster Anthos on bare metal utilizzando Anthos VM Runtime. Il carico di lavoro utilizzato in questa guida è l'applicazione point of sale di esempio. Questa applicazione rappresenta un tipico terminale point of sale eseguito su hardware on-premise in un negozio di vendita al dettaglio.

In questo documento esegui la migrazione di questa applicazione da una VM a un cluster Anthos su Bare Metal e accedi al frontend web dell'applicazione. Per eseguire la migrazione di una VM esistente nel cluster, devi prima creare un'immagine disco di quella VM. Quindi, l'immagine deve essere ospitata in un repository a cui il cluster può accedere. Infine, l'URL di questa immagine può essere utilizzato per creare la VM. Anthos VM Runtime prevede che le immagini siano in formato qcow2. Se fornisci un tipo di immagine diverso, viene convertito automaticamente nel formato qcow2. Per evitare conversioni ripetitive e abilitare il riutilizzo, puoi convertire un'immagine del disco virtuale e ospitare l'immagine qcow2.

Questo documento utilizza un'immagine preliminari di un'istanza VM di Compute Engine in cui il carico di lavoro viene eseguito come servizio systemd. Puoi seguire questi stessi passaggi per eseguire il deployment della tua applicazione.

Obiettivi

• Attiva Anthos VM Runtime e installa il plug-in virtctl
• Esegui il deployment del carico di lavoro basato su VM
• Accedi alla VM e controlla lo stato della richiesta
• Accedi al carico di lavoro basato su VM

Prima di iniziare

Per completare il documento hai bisogno delle seguenti risorse:

• Accedi a un cluster Anthos clusters on bare metal versione 1.12.0 o successiva creato seguendo la guida Esecuzione di cluster Anthos su Bare Metal su VM di Compute Engine con bilanciatore del carico manuale. Questo documento configura le risorse di networking in modo da poter accedere al carico di lavoro in esecuzione all'interno della VM tramite browser. Se questo comportamento non è necessario, puoi seguire questo documento utilizzando qualsiasi cluster Anthos su Bare Metal.
• Una workstation che soddisfi i seguenti requisiti:
  • Ha accesso al cluster tramite l'interfaccia a riga di comando bmctl.
  • Ha accesso al cluster tramite l'interfaccia a riga di comando kubectl.

Abilita Anthos VM Runtime e installa il plug-in virtctl

La definizione di risorse personalizzate (CRD) di Anthos VM Runtime fa parte di tutti i cluster Anthos su cluster Bare Metal dalla versione 1.10. Un'istanza della risorsa personalizzata VMRuntime è già stata creata al momento dell'installazione. ma è disattivata per impostazione predefinita.

1. Abilita Anthos VM Runtime:

   sudo bmctl enable vmruntime --kubeconfig KUBECONFIG_PATH
   

   • KUBECONFIG_PATH: percorso al file di configurazione Kubernetes del cluster utente Anthos

2. Verifica che il VMRuntime sia attivato:

   kubectl wait --for=jsonpath='{.status.ready}'=true vmruntime vmruntime
   

   Potrebbero essere necessari alcuni minuti prima che il VMRuntime sia pronto. Se non è pronto, controlla alcune volte con brevi ritardi. Il seguente output di esempio mostra che VMRuntime è pronto:

   vmruntime.vm.cluster.gke.io/vmruntime condition met
   

3. Installa il plug-in virtctl per kubectl:

   sudo -E bmctl install virtctl
   

   L'output di esempio seguente mostra che il processo di installazione del plug-in virtctl è stato completato:

   Please check the logs at bmctl-workspace/log/install-virtctl-20220831-182135/install-virtctl.log
   [2022-08-31 18:21:35+0000] Install virtctl succeeded
   

4. Verifica l'installazione del plug-in virtctl:

   kubectl virt
   

   L'output di esempio seguente mostra che il plug-in virtctl è disponibile per l'utilizzo con kubectl:

   Available Commands:
     addvolume         add a volume to a running VM
     completion        generate the autocompletion script for the specified shell
     config            Config subcommands.
     console           Connect to a console of a virtual machine instance.
     create            Create subcommands.
     delete            Delete  subcommands.
   ...
   

Esegui il deployment del carico di lavoro basato su VM

Quando esegui il deployment di una VM in Cluster Anthos on bare metal, Anthos VM Runtime prevede un'immagine VM. Questa immagine funge da disco di avvio per la VM di cui è stato eseguito il deployment.

In questo tutorial, esegui la migrazione di un carico di lavoro basato su VM di Compute Engine a un cluster Anthos clusters on bare metal. Questa VM di Compute Engine è stata creata e l'applicazione point of sale di esempio (PoS) è stata configurata per essere eseguita come servizio di sistema. In Google Cloud è stata creata un'immagine disco di questa VM insieme al carico di lavoro dell'applicazione PoS. Questa immagine è stata esportata in un bucket Cloud Storage come immagine qcow2. Nei seguenti passaggi puoi utilizzare questa immagine qcow2 preparata.

Nota: anche se in questo documento utilizziamo una VM di Compute Engine, i passaggi per creare l'immagine disco di una VM variano a seconda dell'ambiente o della piattaforma in cui è attualmente in esecuzione la VM esistente. Puoi creare un'immagine disco delle tue VM esistenti se vuoi seguire i passaggi in questo documento con la tua immagine personalizzata.

Il codice sorgente di questo documento è disponibile nel repository GitHub anthos-samples. Utilizzerai le risorse del repository per completare i passaggi seguenti.

1. Esegui il deployment di un MySQL StatefulSet. L'applicazione point of sale prevede di connettersi a un database MySQL per archiviare l'inventario e i dati di pagamento. Il repository point of sale ha un manifest di esempio che esegue il deployment di un MySQL StatefulSet, configura un ConfigMap associato e un Service di Kubernetes. ConfigMap definisce le credenziali per l'istanza MySQL, che sono le stesse credenziali trasmesse nell'applicazione point of sale.

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/point-of-sale/main/k8-manifests/common/mysql-db.yaml
   

2. Esegui il deployment del carico di lavoro della VM utilizzando l'immagine qcow2 prepreparata:

   kubectl virt create vm pos-vm \
       --boot-disk-size=80Gi \
       --memory=4Gi \
       --vcpu=2 \
       --image=https://storage.googleapis.com/pos-vm-images/pos-vm.qcow2
   

   Questo comando crea un file YAML che prende il nome dalla VM (google-virtctl/pos-vm.yaml). Puoi controllare il file per vedere la definizione di VirtualMachine e VirtualMachineDisk. Invece di utilizzare il plug-in virtctl, avresti potuto eseguire il deployment del carico di lavoro VM utilizzando le definizioni del modello di risorsa Kubernetes (KRM), come mostrato nel file YAML creato.

   Quando il comando viene eseguito correttamente, produce un output come nell'esempio seguente che spiega le diverse risorse create:

   Constructing manifest for vm "pos-vm":
   Manifest for vm "pos-vm" is saved to /home/tfadmin/google-virtctl/pos-vm.yaml
   Applying manifest for vm "pos-vm"
   Created gvm "pos-vm"
   

3. Controlla lo stato di creazione della VM.

   La risorsa VirtualMachine è identificata dalla risorsa vm.cluster.gke.io/v1.VirtualMachine nel runtime VM di Anthos. Il formato breve è gvm.

   Quando crei una VM, vengono create le seguenti due risorse:

   • Una VirtualMachineDisk è il disco permanente in cui vengono importati i contenuti dell'immagine VM.
   • Una VM virtuale è l'istanza VM stessa. Il DataVolume viene montato nella VirtualMachine prima dell'avvio della VM.

   Verifica lo stato di VirtualMachineDisk. VirtualMachineDisk crea internamente una risorsa DataVolume. L'immagine VM viene importata in DataVolume, che è montato nella VM:

   kubectl get datavolume
   

   L'output di esempio seguente mostra l'inizio dell'importazione dell'immagine:

   NAME              PHASE             PROGRESS   RESTARTS   AGE
   pos-vm-boot-dv    ImportScheduled   N/A                   8s
   

4. Controlla lo stato di VirtualMachine. VirtualMachine è in stato Provisioning fino all'importazione completa di DataVolume:

   kubectl get gvm
   

   L'output di esempio seguente mostra il provisioning di VirtualMachine:

   NAME      STATUS         AGE     IP
   pos-vm    Provisioning   1m
   

5. Attendi il completamento dell'importazione dell'immagine VM in DataVolume. Continua a osservare l'avanzamento durante l'importazione dell'immagine:

   kubectl get datavolume -w
   

   L'output di esempio seguente mostra l'immagine del disco importata:

   NAME              PHASE              PROGRESS   RESTARTS   AGE
   pos-vm-boot-dv   ImportInProgress   0.00%                 14s
   ...
   ...
   pos-vm-boot-dv   ImportInProgress   0.00%                 31s
   pos-vm-boot-dv   ImportInProgress   1.02%                 33s
   pos-vm-boot-dv   ImportInProgress   1.02%                 35s
   ...
   

   Una volta completata l'importazione e creata la risorsa DataVolume, l'output di esempio che segue mostra la PHASE di Succeeded :

   kubectl get datavolume
   

   NAME              PHASE             PROGRESS   RESTARTS   AGE
   pos-vm-boot-dv    Succeeded         100.0%                14m18s
   

   Nota: il tempo di importazione dipende dalle dimensioni dell'immagine VM utilizzata. L'immagine VM di Compute Engine in questo documento è di circa 5 GB e richiede fino a 15 minuti per l'importazione.

6. Verifica che il VirtualMachine sia stato creato correttamente:

   kubectl get gvm
   

   Se la creazione è andata a buon fine, STATUS mostra RUNNING, come mostrato nell'esempio seguente, insieme all'indirizzo IP della VM:

   NAME      STATUS    AGE     IP
   pos-vm    Running   40m     192.168.3.250
   

Connettiti alla VM e controlla lo stato dell'applicazione

L'immagine utilizzata per la VM include l'applicazione di esempio del point of sale. L'applicazione è configurata in modo da essere avviata automaticamente all'avvio come servizio di sistema. Puoi visualizzare i file di configurazione dei servizi di sistema nella directory pos-systemd-services.

1. Connettiti alla console VM. Esegui questo comando e premi Invio⏎ dopo aver visualizzato il messaggio Successfully connected to pos-vm…:

   kubectl virt console pos-vm
   

   Questo comando genera il seguente output di esempio che richiede di inserire i dettagli di accesso:

   Successfully connected to pos-vm console. The escape sequence is ^]
   
   pos-from-public-image login:
   

   Utilizza il seguente account utente e la password. Questo account è stato configurato all'interno della VM originale da cui è stata creata l'immagine per la VM virtuale di Anthos VM.

   • Nome utente di accesso: abmuser
   • Password: abmworks

2. Controlla lo stato dei servizi per applicazioni POS. L'applicazione point of sale include tre servizi: API, inventario e pagamenti. Questi servizi vengono tutti eseguiti come servizi di sistema.

   I tre servizi si connettono tra loro tramite localhost. Tuttavia, l'applicazione si connette al database MySQL utilizzando un servizio Kubernetes mysql-db creato nel passaggio precedente. Questo comportamento significa che la VM si connette automaticamente alla stessa rete di Pods e Services, consentendo una comunicazione senza interruzioni tra i carichi di lavoro delle VM e altre applicazioni containerizzate. Non devi fare nulla per rendere Kubernetes Services raggiungibile dalle VM di cui è stato eseguito il deployment utilizzando Anthos VM Runtime.

   sudo systemctl status pos*
   

   L'output di esempio seguente mostra lo stato dei tre servizi e del servizio di sistema principale, pos.service:

   ● pos_payments.service - Payments service of the Point of Sale Application
       Loaded: loaded (/etc/systemd/system/pos_payments.service; enabled; vendor >
       Active: active (running) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
     Main PID: 750 (payments.sh)
         Tasks: 27 (limit: 4664)
       Memory: 295.1M
       CGroup: /system.slice/pos_payments.service
               ├─750 /bin/sh /pos/scripts/payments.sh
               └─760 java -jar /pos/jars/payments.jar --server.port=8083
   
   ● pos_inventory.service - Inventory service of the Point of Sale Application
       Loaded: loaded (/etc/systemd/system/pos_inventory.service; enabled; vendor>
       Active: active (running) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
     Main PID: 749 (inventory.sh)
         Tasks: 27 (limit: 4664)
       Memory: 272.6M
       CGroup: /system.slice/pos_inventory.service
               ├─749 /bin/sh /pos/scripts/inventory.sh
               └─759 java -jar /pos/jars/inventory.jar --server.port=8082
   
   ● pos.service - Point of Sale Application
       Loaded: loaded (/etc/systemd/system/pos.service; enabled; vendor preset: e>
       Active: active (exited) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
     Main PID: 743 (code=exited, status=0/SUCCESS)
         Tasks: 0 (limit: 4664)
       Memory: 0B
       CGroup: /system.slice/pos.service
   
   Jun 21 18:55:30 pos-vm systemd[1]: Starting Point of Sale Application...
   Jun 21 18:55:30 pos-vm systemd[1]: Finished Point of Sale Application.
   
   ● pos_apiserver.service - API Server of the Point of Sale Application
       Loaded: loaded (/etc/systemd/system/pos_apiserver.service; enabled; vendor>
       Active: active (running) since Tue 2022-06-21 18:55:31 UTC; 1h 10min ago
     Main PID: 751 (api-server.sh)
         Tasks: 26 (limit: 4664)
       Memory: 203.1M
       CGroup: /system.slice/pos_apiserver.service
               ├─751 /bin/sh /pos/scripts/api-server.sh
               └─755 java -jar /pos/jars/api-server.jar --server.port=8081
   

3. Esci dalla VM. Per uscire dalla connessione alla console, utilizza la sequenza di escape ^] premendo Ctrl + ].

Accedi al carico di lavoro basato su VM

Se il cluster è stato configurato seguendo la guida Esecuzione di cluster Anthos su Bare Metal su VM di Compute Engine con bilanciatore del carico manuale, ha già una risorsa Ingress denominata pos-ingress. Questa risorsa instrada il traffico dall'indirizzo IP pubblico del bilanciatore del carico in entrata al servizio del server API dell'applicazione di esempio del point of sale.

1. Se il cluster non ha questa risorsa Ingress, creala applicando il seguente manifest:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-samples/main/anthos-bm-gcp-terraform/resources/manifests/pos-ingress.yaml
   

   anthos-bm-gcp-terraform/resources/manifests/pos-ingress.yaml

   Visualizza su GitHub
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: pos-ingress
   spec:
     rules:
     - http:
         paths:
         - path: /
           pathType: Prefix
           backend:
             service:
               name: api-server-svc
               port:
                 number: 8080

2. Crea un Service Kubernetes che indirizzi il traffico alla VM. La risorsa Ingress instrada il traffico a questo Service:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-samples/main/anthos-vmruntime/pos-service.yaml
   

   L'output di esempio seguente conferma la creazione di un servizio:

   service/api-server-svc created
   

   anthos-vmruntime/pos-service.yaml

   Visualizza su GitHub
   apiVersion: v1
   kind: Service
   metadata:
     name: api-server-svc
   spec:
     selector:
       kubevirt/vm: pos-vm
     ports:
     - protocol: TCP
       port: 8080
       targetPort: 8081

3. Recupera l'indirizzo IP pubblico del bilanciatore del carico Ingress. Ingress Il bilanciatore del carico instrada il traffico in base alle regole delle risorse Ingress. Hai già una regola pos-ingress per inoltrare le richieste al server API Service. Questo Service inoltra le richieste alla VM:

   INGRESS_IP=$(kubectl get ingress/pos-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo $INGRESS_IP
   

   L'output di esempio seguente mostra l'indirizzo IP del bilanciatore del carico Ingress:

   172.29.249.159 # you might have a different IP address
   

4. Accedi all'applicazione utilizzando l'indirizzo IP Ingress LoadBalancer in un browser. I seguenti screenshot di esempio mostrano il Kiosk point of sale semplice con due elementi. Puoi fare clic sugli articoli più di una volta se vuoi ordinarne più di uno ed effettuare un ordine con il pulsante Paga. Questa esperienza mostra che hai eseguito correttamente il deployment di un carico di lavoro tradizionale basato su VM in un cluster Anthos utilizzando il runtime VM di Anthos.

UI dell'applicazione point of sale (fai clic sull'immagine per ingrandirla)

Esegui la pulizia

Puoi eliminare tutte le risorse create in questo tutorial o solo la VM e conservare le risorse riutilizzabili. Elimina una VM in Cluster Anthos on bare metal spiega nel dettaglio le opzioni disponibili.

Elimina tutto

• Elimina il runtime VM di Anthos VirtualMachine insieme a tutte le risorse:

  kubectl virt delete vm pos-vm --all
  

  L'output di esempio seguente conferma l'eliminazione:

  vm "pos-vm" used the following resources:
      gvm: pos-vm
      VirtualMachineDisk: pos-vm-boot-dv
  Start deleting the resources:
      Deleted gvm "pos-vm".
      Deleted VirtualMachineDisk "pos-vm-boot-dv".
  

Elimina solo VM

• L'eliminazione solo della VM conserva il VirtualMachineDisk che viene creato. In questo modo puoi riutilizzare questa immagine VM e risparmiare tempo nell'importazione dell'immagine quando crei una nuova VM.

  kubectl virt delete vm pos-vm
  

  L'output di esempio seguente conferma l'eliminazione:

  vm "pos-vm" used the following resources:
      gvm: pos-vm
      VirtualMachineDisk: pos-vm-boot-dv
  Start deleting the resources:
      Deleted gvm "pos-vm".
  

Passaggi successivi

• La VM originale utilizzata in questa guida è un'istanza di Compute Engine che esegue Ubuntu 20.04 LTS. L'immagine di questa VM è accessibile pubblicamente tramite il bucket Cloud Storage pos-vm-images. Per ulteriori informazioni sulla configurazione della VM e sulla creazione dell'immagine, consulta le istruzioni nel repository point of sale.
• Quando crei una VM in un cluster Anthos utilizzando il comando kubectl virt create vm pos-vm, viene creato un file YAML che prende il nome dalla VM (google-virtctl/pos-vm.yaml). Puoi controllare il file per verificare la definizione di VirtualMachine e VirtualMachineDisk. Invece di utilizzare il plug-in virtctl, puoi eseguire il deployment di una VM utilizzando le definizioni di KRM, come mostrato nel file YAML creato.