GSP682
Visão geral
É possível ter instâncias de VM no local gerenciadas por produtos, como o VMWare vSphere, e em nuvens públicas, como o AWS ou o Azure, além de instâncias do Google Cloud Compute Engine.
O Anthos é uma plataforma de aplicativos de código aberto que permite modernizar os aplicativos usados em ambientes híbridos ou de multicloud. Você pode criar e executar novas VMs em qualquer lugar com segurança. O Anthos foi desenvolvido com base em tecnologias de código aberto criadas pelo Google, como o Kubernetes, o Istio e o Knative, para manter a consistência entre ambientes locais e de nuvem.
Com o upgrade das cargas de trabalho para contêineres, os departamentos de TI não só eliminam a manutenção e os patches de segurança no nível do SO para as VMs, como também automatizam as atualizações de política e segurança em escala. O monitoramento de ambientes locais e de nuvem é feito em uma única interface no console do Cloud.
O Migrate to Containers é uma solução quase em tempo real que permite usar uma VM como um pod hospedado do Kubernetes e manter todos os valores associados aos seus aplicativos em um cluster do Kubernetes.
Neste laboratório, você vai criar uma máquina virtual (VM) simples do Compute Engine. Em seguida, vai usar o Migrate to Containers para migrar a VM para um cluster de processamento do GKE na nuvem.
Para executar as etapas, você pode usar a ferramenta migctl
ou o console do Cloud. O migctl
é uma ferramenta de linha de comando para configurar e gerenciar um ambiente de migração do Migrate to Containers no Google Cloud. Além disso, o migctl
está disponível no Cloud Shell.
Como usar o Migrate to Containers para conteinerizar mais rápido do que outras possibilidades:
Objetivos
Você vai aprender a realizar as tarefas a seguir:
- Criar uma instância do Compute Engine que hospeda um servidor da Web
- Criar um cluster do GKE para hospedar a instância do Compute Engine migrado
- Migrar a instância do Compute Engine com o Migrate to Containers
- Testar o servidor da Web que existe no GKE
Configuração e requisitos
Antes de clicar no botão Start Lab
Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.
Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.
Confira os requisitos para concluir o laboratório:
- Acesso a um navegador de Internet padrão (recomendamos o Chrome).
Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.
- Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.
Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.
Como iniciar seu laboratório e fazer login no console do Google Cloud
-
Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento.
No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:
- O botão Abrir console do Google Cloud
- O tempo restante
- As credenciais temporárias que você vai usar neste laboratório
- Outras informações, se forem necessárias
-
Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.
O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.
Dica: coloque as guias em janelas separadas lado a lado.
Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.
-
Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.
{{{user_0.username | "Nome de usuário"}}}
Você também encontra o Nome de usuário no painel Detalhes do laboratório.
-
Clique em Seguinte.
-
Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.
{{{user_0.password | "Senha"}}}
Você também encontra a Senha no painel Detalhes do laboratório.
-
Clique em Seguinte.
Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud.
Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.
-
Acesse as próximas páginas:
- Aceite os Termos e Condições.
- Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
- Não se inscreva em testes gratuitos.
Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.
Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.
Ativar o Cloud Shell
O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.
- Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.
Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:
Your Cloud Platform project in this session is set to YOUR_PROJECT_ID
gcloud
é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.
- (Opcional) É possível listar o nome da conta ativa usando este comando:
gcloud auth list
-
Clique em Autorizar.
-
A saída será parecida com esta:
Saída:
ACTIVE: *
ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- (Opcional) É possível listar o ID do projeto usando este comando:
gcloud config list project
Saída:
[core]
project = <project_ID>
Exemplo de saída:
[core]
project = qwiklabs-gcp-44776a13dea667a6
Observação: para conferir a documentação completa da gcloud
, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.
- Configure uma variável de ambiente para o ID do projeto:
export PROJECT_ID=$DEVSHELL_PROJECT_ID
Tarefa 1: crie o Compute Engine de origem
- Execute o comando a seguir para criar e configurar uma instância do Compute Engine que vai funcionar como a origem da VM a ser migrada:
gcloud compute instances create source-vm --zone={{{project_0.startup_script.lab_zone | zone}}} --machine-type=e2-standard-2 --subnet=default --scopes="cloud-platform" --tags=http-server,https-server --image=ubuntu-minimal-1604-xenial-v20210119a --image-project=ubuntu-os-cloud --boot-disk-size=10GB --boot-disk-type=pd-standard --boot-disk-device-name=source-vm \
--metadata startup-script={{{project_0.startup_script.metadata_script|METADATA_SCRIPT}}}
Você instalou o servidor da Web Apache e criou uma página da Web básica pelo script de inicialização.
Exemplo de resposta:
Created [https://www.googleapis.com/compute/beta/projects/qwiklabs-gcp-02-ace18e67a4ba/zones/{{{project_0.startup_script.lab_zone | zone}}}/instances/source-vm].
NAME: source-vm
ZONE: {{{project_0.startup_script.lab_zone | zone}}}
MACHINE_TYPE: e2-standard-2
PREEMPTIBLE:
INTERNAL_IP: 10.128.0.2
EXTERNAL_IP: 34.70.249.10
STATUS: RUNNING
- Crie uma regra de firewall para permitir o 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
Exemplo de resposta:
Creating firewall...working..Created [https://www.googleapis.com/compute/v1/projects/qwiklabs-gcp-04-1126b7a391de/global/firewalls/default-allow-http].
Creating firewall...done.
NAME: default-allow-http
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 1000
ALLOW: tcp:80
DENY:
DISABLED: False
Clique em Verificar meu progresso para conferir o objetivo.
Crie o Compute Engine de origem
-
No Cloud Console, acesse Compute Engine > Instâncias de VM e encontre a linha da instância que você criou e copie o endereço IP externo.
-
Cole o endereço IP da instância na barra de endereço do navegador. Insira o prefixo http://
.
A página "Hello World!" vai aparecer.
Desative a VM antes da migração.
- No console do Cloud, acesse Compute Engine > Instâncias de VM. Marque a caixa de seleção à esquerda de
source-vm
e depois clique no botão INTERROMPER na parte de cima.
Observação: se não encontrar o botão Interromper, clique no botãoMais ações (três pontos verticais) e selecione "Interromper" no menu suspenso.
- Confirme a desativação clicando em Interromper na janela pop-up. Prossiga para a próxima seção enquanto a VM está sendo desativada.
Observação: interrompa a VM para fazer a migração. É possível reiniciá-la depois de criar a migração abaixo usando a interface ou o comando migctl migration create
.
Tarefa 2: crie um cluster de processamento
Nas etapas a seguir, você vai criar um cluster do GKE na nuvem para ser usado como cluster de processamento. Nele, você vai instalar o Migrate to Containers e executar a migração.
- No Cloud Shell, use o comando a seguir para criar um cluster do Kubernetes, que será usado como centro de processamento:
gcloud container clusters create migration-processing --project=$PROJECT_ID --zone={{{project_0.startup_script.lab_zone | zone}}} --machine-type e2-standard-4 --image-type ubuntu_containerd --num-nodes 3 --enable-stackdriver-kubernetes --subnetwork "projects/$PROJECT_ID/regions/{{{project_0.startup_script.lab_region | region}}}/subnetworks/default"
Observação: especifique a mesma zona estabelecida ao criar a VM.
Exemplo de resposta:
Creating cluster migration-processing in {{{project_0.startup_script.lab_zone | zone}}} ...done.
Created [https://container.googleapis.com/v1/projects/qwiklabs-gcp-04-1126b7a391de/zones/{{{project_0.startup_script.lab_zone | zone}}}/clusters/migration-processing].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/{{{project_0.startup_script.lab_zone | zone}}}/migration-processing?project=qwiklabs-gcp-04-1126b7a391de
kubeconfig entry generated for migration-processing.
NAME: migration-processing
LOCATION: {{{project_0.startup_script.lab_zone | zone}}}
MASTER_VERSION: 1.20.10-gke.301
MASTER_IP: 35.202.0.171
MACHINE_TYPE: e2-standard-4
NODE_VERSION: 1.20.10-gke.301
NUM_NODES: 3
STATUS: RUNNING
Clique em Verificar meu progresso para conferir o objetivo.
Crie um cluster de processamento
Tarefa 3: instale o Migrate to Containers
Para permitir que o Migrate to Containers acesse o Container Registry e o Cloud Storage, você precisa criar uma conta de serviço com o papel storage.admin
.
- No Cloud Shell, crie a conta de serviço
m4a-install
:
gcloud iam service-accounts create m4a-install \
--project=$PROJECT_ID
- Conceda o papel
storage.admin
para a conta de serviço:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:m4a-install@$PROJECT_ID.iam.gserviceaccount.com" \
--role="roles/storage.admin"
- Faça o download do arquivo de chave da conta de serviço:
gcloud iam service-accounts keys create m4a-install.json \
--iam-account=m4a-install@$PROJECT_ID.iam.gserviceaccount.com \
--project=$PROJECT_ID
- Conecte-se ao cluster:
gcloud container clusters get-credentials migration-processing --zone {{{project_0.startup_script.lab_zone | zone}}}
- Para configurar os componentes do Migrate to Containers no cluster de processamento, use a ferramenta de linha de comando
migctl
incluída no Migrate to Containers:
migctl setup install --json-key=m4a-install.json --gcp-project $PROJECT_ID --gcp-region {{{project_0.startup_script.lab_region | region}}}
- Valide a instalação do Migrate to Containers. Use o comando
migctl doctor
para confirmar a implantação:
migctl doctor
Pode levar mais de um minuto para o comando retornar o resultado a seguir.
Exemplo de resposta:
[✓] Deployment
[✓] Docker registry
[✓] Artifacts repo
[x] Source Status
Observação: o Source Status aparece como [x] até você definir a primeira origem de migração abaixo.
- Execute o comando novamente até ver que a implantação foi concluída.
Tarefa 4: migração da VM
Agora você criará um plano de migração com as informações necessárias para migrar a VM.
Para usar o Compute Engine como origem de migração, é preciso primeiro criar uma conta de serviço com os papéis compute.viewer
e compute.storageAdmin
:
- No Cloud Shell, crie a conta de serviço
m4a-ce-src
:
gcloud iam service-accounts create m4a-ce-src \
--project=$PROJECT_ID
- Conceda o papel
compute.viewer
para a conta de serviço:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:m4a-ce-src@$PROJECT_ID.iam.gserviceaccount.com" \
--role="roles/compute.viewer"
- Conceda o papel
compute.storageAdmin
para a conta de serviço:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:m4a-ce-src@$PROJECT_ID.iam.gserviceaccount.com" \
--role="roles/compute.storageAdmin"
- Faça o download do arquivo de chave da conta de serviço:
gcloud iam service-accounts keys create m4a-ce-src.json \
--iam-account=m4a-ce-src@$PROJECT_ID.iam.gserviceaccount.com \
--project=$PROJECT_ID
- Crie a origem da migração:
migctl source create ce source-vm --project $PROJECT_ID --json-key=m4a-ce-src.json
No comando acima, m4a-ce-src.json
especifica a conta de serviço que você criou.
Crie uma migração
Para começar a migração das VMs, é necessário criá-la primeiro. Isso gera um objeto de plano de migração.
Uma migração é o objeto central com que você executa ações de migração, monitora as atividades de migração e o status com a ferramenta "migctl" e o console do Cloud. O objeto de migração é implementado como uma Definição de recurso personalizada (CRD, na sigla em inglês) do Kubernetes.
Para criar uma migração, execute a ferramenta migctl
.
- Crie o plano de migração que define o que será migrado:
migctl migration create my-migration --source source-vm --vm-id source-vm --type linux-system-container
Exemplo de resposta:
Migration my-migration was created. Run `migctl migration status my-migration` to see its status.
- Execute o comando a seguir para verificar o status:
migctl migration status my-migration
Quando o status da migração for "Concluído", você poderá avançar para a próxima etapa.
NAME CURRENT-OPERATION PROGRESS STEP STATUS AGE
my-migration GenerateMigrationPlan [3/3] Discovery Completed 1m30s
Analise o plano de migração
- Neste laboratório, você usará o plano de migração padrão. Agora você fará o download do plano de migração para ser analisado:
migctl migration get my-migration
- Abra o arquivo
my-migration.yaml
para análise em um editor de texto da sua escolha ou no editor de código do Cloud Shell.
Se forem necessárias alterações, faça o upload do novo plano com o comando migctl migration update my-migration
.
Tarefa 5: migre a VM usando o plano de migração
- Este comando fará a migração da VM e criará os artefatos que poderão ser usados para implantar a carga de trabalho:
migctl migration generate-artifacts my-migration
Observação: se a resposta for Error: Migration plan generation is not completed, execute o comando até receber a resposta a seguir.
Exemplo de resposta:
Generate Artifacts task started for Migration my-migration. Run `migctl migration status my-migration` to see its status.
- Após a migração começar, verifique o status com o seguinte comando:
migctl migration status my-migration
A migração pode levar vários minutos.
- Execute de novo o comando até que o status "Concluído" apareça.
NAME CURRENT-OPERATION PROGRESS STEP STATUS AGE
my-migration GenerateArtifacts [3/3] GenerateDeploymentFiles Completed 7m35s
- Você pode adicionar a flag
-v
para conferir o nível de detalhes:
migctl migration status my-migration -v
Tarefa 6: implantação da carga de trabalho migrada
Nos passos a seguir, você receberá os artefatos de implantação gerados durante a migração e os usará para implantar a carga de trabalho migrada no cluster. Como último passo, você confirmará a disponibilidade da página da Web "Hello World!" no app migrado.
- Quando a migração estiver concluída, colete os artefatos YAML gerados:
migctl migration get-artifacts my-migration
O comando faz o download dos arquivos gerados durante a migração:
-
deployment_spec.yaml: o arquivo YAML que configura a carga de trabalho.
-
Dockerfile: usado para criar a imagem da VM migrada.
-
migration.yaml: uma cópia do plano de migração.
-
blocklist.yaml: a lista de serviços de contêiner que devem ser desativados com base nas configurações do plano de migração.
-
Se o editor do Cloud Shell não estiver aberto, clique no botão Abrir editor.
-
Abra o arquivo deployment_spec.yaml e encontre o objeto Service
com o nome source-vm
.
-
Abaixo da definição Service
, adicione outro Service
no final para expor a porta 80 e acessar o servidor da Web por HTTP:
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app: source-vm
ports:
- protocol: TCP
port: 80
targetPort: 80
type: LoadBalancer
Seu arquivo deve ser semelhante a este:
apiVersion: v1
kind: Service
metadata:
creationTimestamp: null
name: source-vm
spec:
clusterIP: None
selector:
app: source-vm
type: ClusterIP
status:
loadBalancer: {}
---
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app: source-vm
ports:
- protocol: TCP
port: 80
targetPort: 80
type: LoadBalancer
-
Salve o arquivo.
-
Aplique deployment_spec.yaml
para implantar a carga de trabalho:
kubectl apply -f deployment_spec.yaml
Exemplo de resposta:
deployment.apps/source-vm created
service/source-vm created
service/my-service created
A implantação pode levar alguns minutos para ser concluída.
- Agora verifique se há um endereço IP externo:
kubectl get service
Exemplo de resposta:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-service LoadBalancer 10.23.253.140 35.184.157.83 80:31060/TCP 11m
kubernetes ClusterIP 10.23.240.1 443/TCP 31m
my-service LoadBalancer 10.23.244.80 104.197.196.94 80:31026/TCP 2m3s
source-vm ClusterIP None 11m
Quando o servidor da Web estiver pronto, você verá um endereço IP externo para o my-service
adicionado.
Tarefa 7: teste a migração
- Para testar a migração, abra um navegador e acesse a página da Web no endereço IP externo de
my-service
. Use HTTP em vez de HTTPS.
Exemplo:
http://<my-service-external-IP>
Clique em Verificar meu progresso para conferir o objetivo.
Verifique a criação de my-service pela migração
Parabéns!
Você usou o Migrate to Containers para migrar uma instância do Compute Engine para um pod do Kubernetes. É possível usar a mesma técnica para outras origens de VMs, como VMWare vSphere, AWS e Azure.
Termine a Quest
Este laboratório autoguiado faz parte da quest VM Migration. Uma Quest é uma série de laboratórios relacionados que formam um programa de aprendizado. Ao concluir uma Quest, você ganha um selo como reconhecimento da sua conquista. É possível publicar os selos e incluir um link para eles no seu currículo on-line ou nas redes sociais. Inscreva-se em qualquer Quest que tenha este laboratório para receber os créditos de conclusão na mesma hora. Consulte o catálogo do Google Cloud Ensina para ver todas as Quests disponíveis.
Comece o próximo laboratório
Próximas etapas/Saiba mais
Finalize o laboratório
Após concluir o laboratório, clique em Terminar o laboratório. Sua conta e os recursos que você utilizou serão removidos da plataforma do laboratório.
Você poderá classificar sua experiência neste laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.
O número de estrelas indica o seguinte:
- 1 estrela = muito insatisfeito
- 2 estrelas = insatisfeito
- 3 estrelas = neutro
- 4 estrelas = satisfeito
- 5 estrelas = muito satisfeito
Feche a caixa de diálogo se não quiser enviar feedback.
Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.
Manual atualizado em 18 de novembro de 2022
Laboratório testado em 6 de junho de 2022
Copyright 2025 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.