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, creerai un'istanza di macchina virtuale (VM) Compute Engine e utilizzerai l'interfaccia a riga di comando Migrate to Containers per eseguire la migrazione della VM a Google Kubernetes Engine (GKE).

Prima di iniziare

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

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

Abilita l'API Compute Engine
Abilitare 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 di Compute Engine che pubblichi 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 relativa alla VM, quindi 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 da utilizzare come macchina locale per eseguire le diverse operazioni 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 relativa alla VM, quindi 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 gcloud CLI, segui le istruzioni visualizzate nella scheda del comando 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 di 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: copia del file system della VM di origine, analisi del file system per creare un piano di migrazione e generazione degli artefatti di migrazione.

Le seguenti sezioni 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 filtri predefiniti per ridurre le dimensioni del file system copiato. Tuttavia, per rendere disponibile il server Apache per l'avvio, il server ha bisogno della directory /var/log, che viene rimossa dai filtri predefiniti.

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

Nella scheda del comando quickstart-local-vm, recupera 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 affermazione:
```
- /var/log/*
```
4. Per salvare il file e uscire dall'editor di testo, premi Esc e premi 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 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 contenente il piano di migrazione config.yaml.

Genera gli artefatti di migrazione

Nella scheda del comando quickstart-local-vm, genera gli artefatti della 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 di cui è stata eseguita la migrazione

In questa sezione, eseguirai il deployment del carico di lavoro di cui è stata eseguita la migrazione dalla 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 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. È simile al seguente:

---
apiVersion: v1
kind: Service
metadata:
creationTimestamp: null
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:
creationTimestamp: null
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 premi Invio :wq.

Esegui il deployment della VM migrata:
```
skaffold run -d eu.gcr.io/PROJECT_ID
```
Recupera 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 è riuscita, 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 è visualizzato il testo Hello World!, la migrazione della VM è riuscita.

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 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 il rilevamento in gruppo degli invitati e la raccolta dei dati.
Per scoprire come eseguire la migrazione di un'applicazione più complessa, consulta il tutorial sulla migrazione di un'applicazione framework Spring disponibile nel repository GitHub di Migrate to Containers.