Esta página foi traduzida pela API Cloud Translation.

Migrar uma VM do Linux usando a CLI do Migrate to Containers

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

Antes de começar

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

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
Ative a API Compute Engine.

Ativar a API do Compute Engine
Ative a API GKE:
Ative a API GKE

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

Nesta seção, você verá como criar uma VM do Compute Engine que exibirá uma página da Web "Hello, World!" que você pode usar para testes após a conclusão da migração.

No console do Google Cloud, clique em Ativar o Cloud Shell.
Acessar o Console do Google Cloud

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 solicitações à instância por 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

Acesse a página Instâncias da VM.

Acessar instâncias de VM
Para se conectar à VM quickstart-source-vm, localize a linha da VM e clique em SSH.

A conexão é estabelecida em uma nova guia.
Na guia do comando quickstart-source-vm, instale o pacote apache2:
```
sudo apt-get update && sudo apt-get install apache2 -y
```
Depois da instalação do Apache, o sistema operacional inicia automaticamente o servidor Apache.

Na mesma guia, substitua a página da Web padrão do servidor da 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

Volte para a página Instâncias de VM e copie o endereço IP externo exibido para quickstart-source-vm.
Cole o endereço IP da VM na barra de endereço do navegador. Insira o prefixo http://.

A página Hello World! é exibida.

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

Nesta seção, você criará uma VM do Linux que pode ser usada como sua máquina local para executar as diferentes operações do Migrate to Containers para migrar a VM de origem.

No console do Google Cloud, clique em Ativar o Cloud Shell.
Acessar o Console do Google Cloud

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 seção, você criará um cluster do GKE no Google Cloud, onde implantará a carga de trabalho conteinerizada posteriormente neste guia de 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.

Preparar a VM local para realizar a migração

Acesse a página Instâncias da VM.

Acessar instâncias de VM
Para se conectar à VM quickstart-local-vm, localize a linha da VM e clique em SSH.

A conexão é estabelecida em uma nova guia.

Na guia do comando quickstart-local-vm, instale a CLI do 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 que aparecem na guia do comando quickstart-local-vm:

Para selecionar a conta a ser usada para realizar várias operações, digite 1.
Para selecionar o projeto em que você criou a VM, digite 1.
Para pular a configuração de uma região e zona padrão, insira n.

Instale o Docker e permita que o usuário não raiz execute contêineres:

# 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/

Faça o download da CLI do 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

Migrar a VM de origem

Geralmente, uma migração envolve três etapas: copiar o sistema de arquivos da VM de origem, analisar o sistema para criar um plano de migração e gerar os artefatos de migração.

As seções a seguir descrevem como usar a CLI do Migrate to Containers para migrar a VM de origem usando a VM local do Linux.

Copiar o sistema de arquivos da VM de origem

Quando você copia um sistema de arquivos da VM de origem, a CLI do Migrate to Containers usa filtros padrão para reduzir o tamanho do sistema de arquivos copiado. No entanto, para disponibilizar o servidor Apache para inicialização, ele precisa do diretório /var/log, que é removido pelos filtros padrão.

Nesta seção, descrevemos como editar os filtros padrão para garantir que /var/log/* seja copiado com o sistema de arquivos da VM de origem.

Na guia do comando quickstart-local-vm, receba uma lista dos filtros padrão do Migrate to Containers em um arquivo chamado filters.txt:
```
./m2c copy default-filters > filters.txt
```
Para editar os filtros padrão, faça o seguinte:
1. Abra o arquivo filters.txt em um editor de texto:
```
vi filters.txt
```
2. Para fazer mudanças no arquivo, pressione i.
3. Remova a seguinte instrução:
```
- /var/log/*
```
4. Para salvar o arquivo e sair do editor de texto, pressione Esc e digite :wq.
Copie o sistema de arquivos da máquina 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 código do projeto.

Uma cópia do sistema de arquivos da máquina de origem está disponível no diretório quickstart-vm-filesystem.

Criar o plano de migração

Na guia do comando 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, um novo diretório chamado analysis-output é criado contendo o plano de migração config.yaml.

Gerar os artefatos de migração

Na guia do comando quickstart-local-vm, gere os artefatos de migração:
```
./m2c generate --input analysis-output --output migration-artifacts
```
Os artefatos de migração gerados são adicionados ao diretório migration-artifacts.

Implantar a carga de trabalho migrada

Nesta seção, você implantará a carga de trabalho migrada da VM local quickstart-local-vm no cluster do GKE em execução no Google Cloud.

Na guia do comando quickstart-local-vm, instale o plug-in gke-gcloud-auth-plugin:
```
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
Instale kubectl:
```
sudo apt-get install kubectl
```

Conecte-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 na Internet, adicione um novo serviço LoadBalancer no arquivo deployment_spec.yaml. Para editar o arquivo deployment_spec.yaml, faça o seguinte:

Abra o arquivo deployment_spec.yaml em um editor de texto:
```
vi deployment_spec.yaml
```
Para fazer mudanças no arquivo, pressione i.

Localize o objeto Service com o nome linux-system. Ele é 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

Adicione outro objeto Service com o nome hello-service logo 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 salvar o arquivo e sair do editor de texto, pressione Esc e digite :wq.

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

Quando o servidor da Web estiver pronto, você verá um endereço IP externo para a hello-service adicionada.

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 uma nova guia do navegador e acesse a página da Web no endereço IP externo.
```
http://EXTERNAL_IP
```
Use HTTP, e não HTTPS.
Se o texto Hello World! aparecer na tela, a migração da VM foi concluída.

Se você não conseguir acessar a carga de trabalho migrada, veja como solucionar problemas conhecidos.

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

Excluir o cluster do GKE

No console do Google Cloud, abra a página GKE.
Acessar o GKE
Selecione quickstart-cluster e clique em Excluir.
Quando solicitado a confirmar, clique em Excluir novamente.

Excluir as VMs

No console do Google Cloud, acesse a página Instâncias de VMs.
Acessar instâncias de VM
Clique no nome quickstart-source-vm.
Na parte superior da página de detalhes da instância, clique em Excluir.
Clique no nome quickstart-local-vm.
Na parte superior da página de detalhes da instância, clique em Excluir.

A seguir

Saiba como locar a descoberta de convidados e a coleta de dados.
Para saber como migrar um aplicativo mais complexo, consulte o tutorial de migração de um aplicativo do framework do Spring disponível no repositório do GitHub sobre a migração para contêineres.