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 em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Basta remover todos os recursos associados a ele.

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

Ativar a API Compute Engine
Ative a API GKE.
Ativar 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 exibe uma página da Web Hello, World! que você poderá usar para testes após concluir a migração.

No console do Google Cloud , clique em Activate 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 de VM.

Acessar Instâncias de VM
Para se conectar a quickstart-source-vm da 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.

Criar um cluster do GKE

Nesta seção, você criará um cluster do GKE no Google Cloud. Mais adiante neste guia de início rápido, você implantará a carga de trabalho conteinerizada nele.

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 de VM.

Acessar Instâncias de VM
Para se conectar a quickstart-local-vm da 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 do gcloud CLI, siga as instruções que aparecem na guia do comando quickstart-local-vm:

Para selecionar a conta em que vai 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/

Baixe a 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

Uma migração geralmente 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 da 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, você verá 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:
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 insira :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 ID 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 do quickstart-local-vm da VM local 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 o 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 de LoadBalancer no arquivo deployment_spec.yaml. Para editar o arquivo deployment_spec.yaml:

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 insira :wq.

Implante a VM migrada:
```
skaffold run -d eu.gcr.io/PROJECT_ID
```
Verifique 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 o hello-service adicionado.

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 concluída, abra uma nova guia do navegador e acesse a página da Web no endereço IP externo.
```
http://EXTERNAL_IP
```
Use HTTP, 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 as etapas abaixo.

Excluir o cluster do GKE

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

Excluir as VMs.

No console do Google Cloud , acesse a página Instâncias de VM:
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.

Qual é a próxima etapa?

Saiba como realizar a descoberta de convidados e a coleta de dados em lote.
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 do Migrate to Containers.