Questa pagina è stata tradotta dall'API Cloud Translation.

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

In questa guida rapida, crei un'istanza di macchina virtuale (VM) Compute Engine, quindi utilizzi il comando Migrate to Containers CLI 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 esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

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

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

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

Questa sezione descrive come creare una VM Compute Engine che serve una pagina web Hello World! che puoi utilizzare per i test al termine 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 corrispondente e fai clic su SSH.

La connessione viene stabilita in una nuova scheda.
Nella scheda dei comandi 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 Compute Engine da utilizzare come macchina locale

In questa sezione crei una VM Linux che puoi 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, crei un cluster GKE in Google Cloud, dove eseguirai il deployment del carico di lavoro containerizzato in un secondo momento 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 corrispondente e fai clic su SSH.

La connessione viene stabilita in una nuova scheda.

Nella scheda dei comandi 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 riportate 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 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 elementi della migrazione.

Le sezioni seguenti descrivono come utilizzare l'interfaccia a riga di comando 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 il file system di una VM di origine, l'interfaccia a riga di comando Migrate to Containers utilizza i filtri predefiniti per ridurre le dimensioni del file system copiato. Tuttavia, per rendere disponibile il server Apache all'avvio, il server ha bisogno della directory /var/log, che viene rimossa dai filtri predefiniti.

Questa sezione descrive come modificare i filtri predefiniti per assicurarti 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 di Migrate to Containers predefiniti 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 affermazione:
```
- /var/log/*
```
4. Per salvare il file ed uscire dall'editor di testo, premi Esc e poi Invio: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 dei comandi 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 dei comandi quickstart-local-vm, genera gli elementi di migrazione:
```
./m2c generate --input analysis-output --output migration-artifacts
```
Gli elementi della migrazione generati vengono aggiunti alla directory migration-artifacts.

Esegui il deployment del carico di lavoro sottoposto a migrazione

In questa sezione esegui il deployment del carico di lavoro sottoposto a migrazione dalla VM localequickstart-local-vm al cluster GKE in esecuzione su Google Cloud.

Nella scheda dei comandi 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 carico di lavoro 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. L'aspetto sarà 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 denominato 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 ed uscire dall'editor di testo, premi Esc e poi Invio: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 server web è pronto, viene visualizzato un indirizzo IP esterno per il 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 sottoposto a 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 e poi 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 in batch il rilevamento degli ospiti e la raccolta dei dati.
Per scoprire come eseguire la migrazione di un'applicazione più complessa, consulta il tutorial sulla migrazione di un'applicazione Spring Framework disponibile nel repository GitHub di Migrate to Containers.