Esta página foi traduzida pela API Cloud Translation.

Migre uma VM do Linux com a CLI do Migrate to Containers

Neste início rápido, vai criar uma instância de máquina virtual (VM) do Compute Engine e, em seguida, usar a CLI Migrate to Containers para migrar a VM para o Google Kubernetes Engine (GKE).

Antes de começar

Na Google Cloud consola, na página do seletor de projetos, selecione ou crie um Google Cloud projeto.

Nota: se não planeia manter os recursos que criar neste procedimento, crie um projeto em vez de selecionar um projeto existente. Depois de concluir estes passos, pode eliminar o projeto, removendo todos os recursos associados ao projeto.

Aceder ao seletor de projetos
Certifique-se de que a faturação está ativada para o seu Google Cloud projeto. Saiba como verificar se a faturação está ativada num projeto.
Ative a API Compute Engine.

Ative a API Compute Engine
Ative a API GKE.
Ative a API GKE

Crie uma VM do Compute Engine com um servidor Web para usar como VM de origem

Esta secção descreve como criar uma VM do Compute Engine que disponibiliza uma página Web Hello World! que pode usar para testes após a conclusão da migração.

Na Google Cloud consola, clique em Ativar Cloud Shell.
Aceda à Google Cloud consola

Crie uma 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

Aguarde alguns minutos para que a criação da VM seja concluída.

Crie uma regra de firewall que permita pedidos à instância através de 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

Aceda à página Instâncias de VM.

Aceder às instâncias de VM
Para estabelecer ligação à VM quickstart-source-vm, localize a linha da VM e, de seguida, clique em SSH.

A ligação é estabelecida num novo separador.
No separador de comandos quickstart-source-vm, instale o pacote apache2:
```
sudo apt-get update && sudo apt-get install apache2 -y
```
Após a instalação do Apache, o sistema operativo inicia automaticamente o servidor Apache.

No mesmo separador, substitua a página Web predefinida do servidor Web Apache por uma nova página:

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

Regresse à página VM instances e copie o endereço External IP apresentado para quickstart-source-vm.
Cole o endereço IP da VM na barra de endereço do navegador. Adicione o prefixo http://.

É apresentada a página Olá, mundo!.

Crie uma VM do Compute Engine para usar como uma máquina local

Nesta secção, cria uma VM Linux que pode usar como máquina local para realizar as diferentes operações de migração para contentores para migrar a VM de origem.

Na Google Cloud consola, clique em Ativar Cloud Shell.
Aceda à Google Cloud consola

Crie uma 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

Aguarde alguns minutos para que a criação da VM seja concluída.

Crie um cluster do GKE

Nesta secção, cria um cluster do GKE em Google Cloud, onde implementa a sua carga de trabalho em contentores mais tarde neste início rápido.

No Cloud Shell, crie um novo cluster do 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

Aguarde alguns minutos para que a criação do cluster seja concluída.

Prepare a VM local para realizar a migração

Aceda à página Instâncias de VM.

Aceder às instâncias de VM
Para estabelecer ligação à VM quickstart-local-vm, localize a linha da VM e, de seguida, clique em SSH.

A ligação é estabelecida num novo separador.

No separador de comandos quickstart-local-vm, instale a CLI Google Cloud:

# 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

Para concluir a configuração da CLI gcloud, siga as instruções apresentadas no separador de comandos quickstart-local-vm:

Para selecionar a conta a usar para realizar várias operações, introduza 1.
Para selecionar o projeto no qual criou a VM, introduza 1.
Para ignorar a configuração de uma região e uma zona predefinidas, introduza n.

Instale o Docker e permita que o utilizador sem acesso de raiz execute contentores:

# 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

Instale o Skaffold:

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

Transfira a CLI 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

Migre a VM de origem

Normalmente, uma migração envolve três passos: copiar o sistema de ficheiros da VM de origem, analisar o sistema de ficheiros para criar um plano de migração e gerar os artefactos de migração.

As secções seguintes descrevem como usar a CLI Migrate to Containers para migrar a VM de origem através da sua VM Linux local.

Copie o sistema de ficheiros da VM de origem

Quando copia um sistema de ficheiros de VM de origem, a CLI Migrate to Containers usa filtros predefinidos para reduzir o tamanho do sistema de ficheiros copiado. No entanto, para disponibilizar o servidor Apache para arranque, o servidor precisa do diretório /var/log, que é removido pelos filtros predefinidos.

Esta secção descreve como editar os filtros predefinidos para garantir que o diretório /var/log/* é copiado com o sistema de ficheiros da VM de origem.

No separador de comandos quickstart-local-vm, obtenha uma lista dos filtros Migrar para contentores predefinidos num ficheiro denominado filters.txt:
```
./m2c copy default-filters > filters.txt
```
Para editar os filtros predefinidos, faça o seguinte:
1. Abra o ficheiro filters.txt num editor de texto:
```
vi filters.txt
```
2. Para fazer alterações no ficheiro, prima i.
3. Remova a seguinte declaração:
```
- /var/log/*
```
4. Para guardar o ficheiro e sair do editor de texto, prima Esc e, de seguida, introduza :wq.
Copie o sistema de ficheiros do computador de origem:
```
./m2c copy gcloud \
  --project PROJECT_ID --zone us-central1-a \
  --vm-name quickstart-source-vm --output quickstart-vm-filesystem \
  --filters filters.txt
```
Substitua PROJECT_ID pelo ID do projeto.

Está disponível uma cópia do sistema de ficheiros da máquina de origem no diretório quickstart-vm-filesystem.

Crie o plano de migração

No separador de comandos quickstart-local-vm, crie o plano de migração:
```
./m2c analyze \
  --source quickstart-vm-filesystem --plugin linux-vm-container \
  --output analysis-output
```
Após a conclusão da análise, é criado um novo diretório denominado analysis-output, que contém o plano de migração, config.yaml.

Gere os artefactos de migração

No separador de comandos quickstart-local-vm, gere os artefactos de migração:
```
./m2c generate --input analysis-output --output migration-artifacts
```
Os artefactos de migração gerados são adicionados ao diretório migration-artifacts.

Implemente a carga de trabalho migrada

Nesta secção, implementa a carga de trabalho migrada a partir da sua VM local quickstart-local-vm para o cluster do GKE em execução no Google Cloud.

No separador de comandos quickstart-local-vm, instale o gke-gcloud-auth-plugin plug-in:
```
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
Instale kubectl:
```
sudo apt-get install kubectl
```

Ligue-se ao cluster quickstart-cluster:

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

Abra a pasta migration-artifacts:
```
cd migration-artifacts
```

Para expor a carga de trabalho à Internet, adicione um novo serviço LoadBalancer no ficheiro deployment_spec.yaml. Para editar o ficheiro deployment_spec.yaml, faça o seguinte:

Abra o ficheiro deployment_spec.yaml num editor de texto:
```
vi deployment_spec.yaml
```
Para fazer alterações no ficheiro, prima i.

Localize o objeto Service com o nome linux-system. Aparece semelhante ao seguinte:

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

Adiciona outro objeto Service denominado hello-service imediatamente após 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

Para guardar o ficheiro e sair do editor de texto, prima Esc e, de seguida, introduza :wq.

Implemente a VM migrada:
```
skaffold run -d eu.gcr.io/PROJECT_ID
```
Obtenha o endereço IP externo da VM migrada:
```
kubectl get service hello-service
```

Quando o servidor Web estiver pronto, vê um endereço IP externo para o hello-service que adicionou.

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

Para verificar se a migração foi bem-sucedida, abra um novo separador do navegador e visite a página Web no endereço IP externo.
```
http://EXTERNAL_IP
```
Certifique-se de que usa HTTP e não HTTPS.
Se vir o texto Hello World! apresentado no ecrã, a migração da MV foi bem-sucedida.

Se não conseguir aceder à sua carga de trabalho migrada, saiba como resolver problemas conhecidos.

Limpar

Para evitar incorrer em cobranças na sua Google Cloud conta pelos recursos usados nesta página, siga estes passos.

Elimine o cluster do GKE

Na Google Cloud consola, aceda à página GKE.
Aceda ao GKE
Selecione quickstart-cluster e, de seguida, clique em Eliminar.
Quando lhe for pedido que confirme, clique novamente em Eliminar.

Elimine as VMs

Na Google Cloud consola, aceda à página Instâncias de VM.
Aceder às instâncias de VM
Clique no nome quickstart-source-vm.
Na parte superior da página de detalhes da instância, clique em Eliminar.
Clique no nome quickstart-local-vm.
Na parte superior da página de detalhes da instância, clique em Eliminar.

O que se segue?

Saiba como processar em lote a deteção de convidados e a recolha de dados.
Para saber como migrar uma aplicação mais complexa, consulte o tutorial de migração de uma aplicação Spring Framework disponível no repositório do GitHub Migrate to Containers.