Esegui la migrazione di una VM Linux utilizzando l'interfaccia a riga di comando di Migrate to Containers

In questa guida rapida, crei un'istanza di macchina virtuale (VM) Compute Engine, quindi utilizzi la CLI Migrate to Containers per eseguire la migrazione della VM a Google Kubernetes Engine (GKE).

Prima di iniziare

Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

Vai al selettore di progetti
Verifica che la fatturazione sia abilitata per il tuo progetto Google Cloud . Scopri come verificare se la fatturazione è abilitata per un progetto.
Abilita l'API Compute Engine

Abilita l'API Compute Engine
Abilita l'API GKE.
Abilita l'API GKE

Crea una VM di Compute Engine con un server web da utilizzare come VM di origine

Questa sezione descrive come creare una VM Compute Engine che pubblica una pagina web Hello World! che puoi utilizzare per i test dopo il completamento della migrazione.

Nella console Google Cloud , fai clic su Attiva Cloud Shell.
Vai alla console Google Cloud

Crea una VM:

gcloud compute instances create quickstart-source-vm \
  --zone=us-central1-a --machine-type=e2-medium  \
  --subnet=default --scopes="cloud-platform" \
  --tags=http-server,https-server --image=ubuntu-2204-jammy-v20240208 \
  --image-project=ubuntu-os-cloud --boot-disk-size=10GB --boot-disk-type=pd-standard \
  --boot-disk-device-name=quickstart-source-vm

Attendi qualche minuto per il completamento della creazione della VM.

Crea una regola firewall che consenta le richieste all'istanza tramite HTTP:

gcloud compute firewall-rules create default-allow-http \
  --direction=INGRESS --priority=1000 --network=default --action=ALLOW \
  --rules=tcp:80 --source-ranges=0.0.0.0/0 --target-tags=http-server

Vai alla pagina Istanze VM.

Vai a Istanze VM
Per connetterti alla VM quickstart-source-vm, individua la riga della VM e fai clic su SSH.

La connessione viene stabilita in una nuova scheda.
Nella scheda del comando quickstart-source-vm, installa il pacchetto apache2:
```
sudo apt-get update && sudo apt-get install apache2 -y
```
Dopo aver installato Apache, il sistema operativo avvia automaticamente il server Apache.

Nella stessa scheda, sovrascrivi la pagina web predefinita del server web Apache con una nuova pagina:

echo '<!doctype html><html><body><h1>Hello World!</h1></body></html>' | sudo tee /var/www/html/index.html

Torna alla pagina Istanze VM e copia l'indirizzo IP esterno visualizzato per quickstart-source-vm.
Incolla l'indirizzo IP della VM nella barra degli indirizzi del browser. Aggiungi il prefisso http://.

Viene visualizzata la pagina Hello World!.

Crea una VM di Compute Engine da utilizzare come macchina locale

In questa sezione, creerai una VM Linux che potrai utilizzare come macchina locale per eseguire le diverse operazioni di Migrate to Containers per la migrazione della VM di origine.

Nella console Google Cloud , fai clic su Attiva Cloud Shell.
Vai alla console Google Cloud

Crea una VM:

gcloud compute instances create quickstart-local-vm \
  --zone=us-central1-a --machine-type=e2-medium  \
  --subnet=default --scopes="cloud-platform" \
  --tags=http-server,https-server --image=ubuntu-2204-jammy-v20240208 \
  --image-project=ubuntu-os-cloud --boot-disk-size=50GB --boot-disk-type=pd-standard \
  --boot-disk-device-name=quickstart-local-vm

Attendi qualche minuto per il completamento della creazione della VM.

Crea un cluster GKE

In questa sezione creerai un cluster GKE in Google Cloud, in cui eseguirai il deployment del carico di lavoro containerizzato più avanti in questa guida rapida.

In Cloud Shell, crea un nuovo cluster Kubernetes:

gcloud container clusters create quickstart-cluster \
  --zone=us-central1-a --machine-type=e2-medium \
  --image-type=ubuntu_containerd --num-nodes=1 \
  --logging=SYSTEM,WORKLOAD,API_SERVER,SCHEDULER,CONTROLLER_MANAGER

Attendi qualche minuto per il completamento della creazione del cluster.

Prepara la VM locale per eseguire la migrazione

Vai alla pagina Istanze VM.

Vai a Istanze VM
Per connetterti alla VM quickstart-local-vm, individua la riga della VM e fai clic su SSH.

La connessione viene stabilita in una nuova scheda.

Nella scheda del comando quickstart-local-vm, installa Google Cloud CLI:

# Import the Google Cloud public key.
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg

# Add the gcloud CLI distribution URI as a package source
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

# Update and install gcloud
sudo apt-get update && sudo apt-get install google-cloud-cli

# Get started
gcloud init

Per completare la configurazione di gcloud CLI, segui le istruzioni visualizzate nella scheda dei comandi quickstart-local-vm:

Per selezionare l'account da utilizzare per eseguire varie operazioni, inserisci 1.
Per selezionare il progetto in cui hai creato la VM, inserisci 1.
Per saltare la configurazione di una regione e una zona predefinite, inserisci n.

Installa Docker e consenti all'utente non root di eseguire i container:

# Download the convenience script
curl -fsSL https://get.docker.com -o install-docker.sh

# Install Docker
sudo sh install-docker.sh

# Allow the non-root user to access Docker
sudo usermod -aG docker $USER

# Activate the group changes
newgrp docker

Installa Skaffold:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && \
sudo install skaffold /usr/local/bin/

Scarica l'interfaccia a riga di comando di Migrate to Containers:

curl -O "https://m2c-cli-release.storage.googleapis.com/$(curl -s https://m2c-cli-release.storage.googleapis.com/latest)/linux/amd64/m2c"
chmod +x ./m2c

Esegui la migrazione della VM di origine

Una migrazione in genere prevede tre passaggi: la copia del file system della VM di origine, l'analisi del file system per creare un piano di migrazione e la generazione degli artefatti di migrazione.

Le sezioni seguenti descrivono come utilizzare l'interfaccia a riga di comando di Migrate to Containers per eseguire la migrazione della VM di origine utilizzando la VM Linux locale.

Copia il file system della VM di origine

Quando copi un file system della VM di origine, Migrate to Containers CLI utilizza filtri predefiniti per ridurre le dimensioni del file system copiato. Tuttavia, per rendere disponibile l'avvio del server Apache, il server ha bisogno della directory /var/log, che viene rimossa dai filtri predefiniti.

Questa sezione descrive come modificare i filtri predefiniti per assicurarsi che /var/log/* venga copiato con il file system della VM di origine.

Nella scheda del comando quickstart-local-vm, ottieni un elenco dei filtri predefiniti Migrate to Containers in un file denominato filters.txt:
```
./m2c copy default-filters > filters.txt
```
Per modificare i filtri predefiniti:
1. Apri il file filters.txt in un editor di testo:
```
vi filters.txt
```
2. Per apportare modifiche al file, premi i.
3. Rimuovi la seguente dichiarazione:
```
- /var/log/*
```
4. Per salvare il file e uscire dall'editor di testo, premi Esc e poi inserisci :wq.
Copia il file system della macchina di origine:
```
./m2c copy gcloud \
  --project PROJECT_ID --zone us-central1-a \
  --vm-name quickstart-source-vm --output quickstart-vm-filesystem \
  --filters filters.txt
```
Sostituisci PROJECT_ID con l'ID del progetto.

Una copia del file system della macchina di origine è disponibile nella directory quickstart-vm-filesystem.

Crea il piano di migrazione

Nella scheda del comando quickstart-local-vm, crea il piano di migrazione:
```
./m2c analyze \
  --source quickstart-vm-filesystem --plugin linux-vm-container \
  --output analysis-output
```
Al termine dell'analisi, viene creata una nuova directory denominata analysis-output che contiene il piano di migrazione, config.yaml.

Genera gli artefatti di migrazione

Nella scheda del comando quickstart-local-vm, genera gli artefatti di migrazione:
```
./m2c generate --input analysis-output --output migration-artifacts
```
Gli artefatti di migrazione generati vengono aggiunti alla directory migration-artifacts.

Esegui il deployment del carico di lavoro migrato

In questa sezione, esegui il deployment del carico di lavoro migrato dalla tua VM locale quickstart-local-vm al cluster GKE in esecuzione su Google Cloud.

Nella scheda del comando quickstart-local-vm, installa il plug-in gke-gcloud-auth-plugin:
```
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
Installa kubectl:
```
sudo apt-get install kubectl
```

Connettiti al cluster quickstart-cluster:

gcloud container clusters get-credentials quickstart-cluster \
  --zone us-central1-a --project PROJECT_ID

Apri la cartella migration-artifacts:
```
cd migration-artifacts
```

Per esporre il workload a internet, aggiungi un nuovo servizio LoadBalancer nel file deployment_spec.yaml. Per modificare il file deployment_spec.yaml:

Apri il file deployment_spec.yaml in un editor di testo:
```
vi deployment_spec.yaml
```
Per apportare modifiche al file, premi i.

Individua l'oggetto Service con il nome linux-system. Avrà un aspetto simile al seguente:

apiVersion: v1
kind: Service
metadata:
  labels:
    anthos-migrate.cloud.google.com/type: linux-container
    migrate-for-anthos-optimization: "true"
    migrate-for-anthos-version: m2c-cli-1.2.2
  name: linux-system
spec:
  clusterIP: None
  selector:
    app: linux-system
  type: ClusterIP

Aggiungi un altro oggetto Service chiamato hello-service subito dopo linux-system:

apiVersion: v1
kind: Service
metadata:
  labels:
    anthos-migrate.cloud.google.com/type: linux-container
    migrate-for-anthos-optimization: "true"
    migrate-for-anthos-version: m2c-cli-1.2.2
  name: linux-system
spec:
  clusterIP: None
  selector:
    app: linux-system
  type: ClusterIP
---
# Add the hello-service object
apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  selector:
    app: linux-system
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Per salvare il file e uscire dall'editor di testo, premi Esc e poi inserisci :wq.

Esegui il deployment della VM migrata:
```
skaffold run -d eu.gcr.io/PROJECT_ID
```
Ottieni l'indirizzo IP esterno della VM di cui è stata eseguita la migrazione:
```
kubectl get service hello-service
```

Quando il web server è pronto, viene visualizzato un indirizzo IP esterno per hello-service che hai aggiunto.

NAME            TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
hello-service   LoadBalancer   10.23.241.124   EXTERNAL_IP   80:32611/TCP   5m4s

Per verificare se la migrazione è andata a buon fine, apri una nuova scheda del browser e visita la pagina web all'indirizzo IP esterno.
```
http://EXTERNAL_IP
```
Assicurati di utilizzare HTTP e non HTTPS.
Se sullo schermo viene visualizzato il testo Hello World!, la migrazione della VM è andata a buon fine.

Se non riesci ad accedere al carico di lavoro di cui è stata eseguita la migrazione, scopri come risolvere i problemi noti.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

Elimina il cluster GKE

Nella console Google Cloud , vai alla pagina GKE.
Vai a GKE
Seleziona quickstart-cluster, quindi fai clic su Elimina.
Quando ti viene chiesto di confermare, fai di nuovo clic su Elimina.

Elimina le VM

Nella console Google Cloud , vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic sul nome quickstart-source-vm.
Nella parte superiore della pagina dei dettagli dell'istanza, fai clic su Elimina.
Fai clic sul nome quickstart-local-vm.
Nella parte superiore della pagina dei dettagli dell'istanza, fai clic su Elimina.

Passaggi successivi

Scopri come eseguire il rilevamento e la raccolta dei dati degli ospiti in batch.
Per scoprire come eseguire la migrazione di un'applicazione più complessa, consulta l'esercitazione sulla migrazione di un'applicazione Spring Framework disponibile nel repository GitHub Migrate to Containers.