arrow_back

Como migrar um site monolítico para microsserviços no Google Kubernetes Engine

Como migrar um site monolítico para microsserviços no Google Kubernetes Engine

1 hora 30 minutos 5 créditos

GSP699

Laboratórios autoguiados do Google Cloud

Introdução

Por que migrar de um aplicativo monolítico para uma arquitetura de microsserviços? Dividir um aplicativo em microsserviços é vantajoso, principalmente porque a dependência entre os microsserviços é mínima. Com essa abordagem, você tem as seguintes opções:

  • É possível testar e implantar os microsserviços de maneira independente. Quanto menor for a unidade a ser implantada, mais fácil será o processo.
  • Os microsserviços podem ser implementados em linguagens e frameworks diferentes. Você tem liberdade para escolher a tecnologia mais adequada ao uso específico de cada microsserviço.
  • Os microsserviços podem ser gerenciados por equipes diferentes. Como os microsserviços têm limites bem definidos, fica fácil atribuir um ou vários deles a uma equipe.
  • Ao migrar para os microsserviços, você reduz a dependência entre as equipes. Cada equipe passa a se preocupar apenas com as APIs dos microsserviços que deve gerenciar. Elas não precisam pensar sobre como os microsserviços são implementados, os ciclos de lançamento e outros fatores.
  • É mais fácil se preparar para falhas. Como o limite entre os serviços é claro, fica mais fácil determinar o que fazer se um deles falhar.

Veja algumas desvantagens em comparação com um site monolítico:

  • Como um app baseado em microsserviços é uma rede de serviços diferentes que geralmente interagem de maneiras que não são óbvias, a complexidade do sistema tende a aumentar.
  • Ao contrário dos componentes internos de um aplicativo monolítico, os microsserviços se comunicam por uma rede. Em algumas circunstâncias, isso pode ser visto como um risco para a segurança. O Istio soluciona esse problema ao criptografar automaticamente o tráfego entre os microsserviços.
  • Pode ser difícil ter o mesmo desempenho de uma abordagem monolítica devido às latências entre os serviços.
  • O comportamento do sistema não é definido por um único serviço, mas por muitos e pelas interações entre eles. Por isso, entender como o sistema se comporta na produção (observabilidade) é mais difícil. O Istio também é uma solução para esse problema.

Neste laboratório, você implantará um aplicativo monolítico pronto no cluster do Google Kubernetes Engine e o dividirá em microsserviços. O Kubernetes é uma plataforma para gerenciar, hospedar, escalonar e implantar contêineres. Os contêineres são uma maneira portátil de empacotar e executar um código. Eles são ideais para o padrão dos microsserviços, porque cada microsserviço pode ser executado em um contêiner próprio.

Diagrama da arquitetura dos microsserviços

Comece dividindo o aplicativo monolítico em três microsserviços, um de cada vez. Os microsserviços são: Orders, Products e Frontend. Crie uma imagem do Docker para cada microsserviço usando o Cloud Build. Depois implante e exponha os microsserviços no Google Kubernetes Engine (GKE) com um serviço do tipo LoadBalancer do Kubernetes. Você fará isso para cada serviço, enquanto eles são refatorados simultaneamente no aplicativo monolítico. O aplicativo monolítico e os microsserviços funcionarão em paralelo até o final do processo, quando você poderá excluir o aplicativo monolítico.

636a2d58588b2b87.png

O que você aprenderá

  • Como dividir um aplicativo monolítico em microsserviços

  • Como criar um cluster do Google Kubernetes Engine

  • Como criar uma imagem do Docker

  • Como implantar imagens do Docker no Kubernetes

Pré-requisitos

  • Uma conta do Google Cloud Platform com acesso administrativo para criar projetos ou um projeto com o papel "Proprietário do projeto"

  • Noções básicas do Docker e do Kubernetes

Configuração do ambiente

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 ficarão disponíveis.

Este laboratório prático do Qwiklabs permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você receberá novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

O que é necessário

Para fazer este laboratório, você precisa ter:

  • acesso a um navegador de Internet padrão (recomendamos o Chrome);
  • tempo para concluir as atividades.

Observação: não use seu projeto ou sua conta do Google Cloud neste laboratório.

Observação: se estiver usando um dispositivo Chrome OS, abra uma janela anônima para executar o laboratório.

Como iniciar seu laboratório e fazer login no console do Google Cloud

  1. 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ê verá o seguinte:

    • O botão Abrir Console do Cloud
    • Tempo restante
    • As credenciais temporárias que você vai usar neste laboratório
    • Outras informações se forem necessárias
  2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

    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.
  3. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

  4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

    Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.
  5. 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 GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo. Ícone do menu de navegação

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com ferramentas de desenvolvimento. Ele conta com um diretório principal permanente de 5 GB e é executado no Google Cloud. O Google Cloud Shell permite acesso de linha de comando aos seus recursos do GCP.

  1. No Console do GCP, na barra de ferramentas superior direita, clique no botão Abrir o Cloud Shell.

    Ícone do Cloud Shell

  2. Clique em Continue (continuar):

    cloudshell_continue

Demora alguns minutos para provisionar e conectar-se ao ambiente. Quando você está conectado, você já está autenticado e o projeto é definido como seu PROJECT_ID . Por exemplo:

Terminal do Cloud Shell

gcloud é a ferramenta de linha de comando do Google Cloud Platform. Ele vem pré-instalado no Cloud Shell e aceita preenchimento com tabulação.

É possível listar o nome da conta ativa com este comando:

gcloud auth list

Saída:

ACTIVE: *
ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net
To set the active account, run:
    $ gcloud config set account `ACCOUNT`
	

É possível listar o ID de projeto com este comando:

gcloud config list project
	

Saída:

[core]
project = <project_ID>
	

Exemplo de saída:

[core]
project = qwiklabs-gcp-44776a13dea667a6
	

Defina a zona padrão e a configuração do projeto:

gcloud config set compute/zone us-central1-f

Clone o repositório de origem

Você usará um aplicativo monolítico pronto de um site fictício de e-commerce que inclui: uma página de boas-vindas simples, uma página de produtos e uma página com o histórico dos pedidos. Clone a origem do repositório do Git para poder dividir o aplicativo em microsserviços e implantá-lo no Google Kubernetes Engine (GKE).

Execute os comandos a seguir para clonar o repositório do Git na sua instância do Cloud Shell. Depois acesse o diretório correto. Instale as dependências do NodeJS para testar o aplicativo monolítico antes da implantação:

cd ~
git clone https://github.com/googlecodelabs/monolith-to-microservices.git
cd ~/monolith-to-microservices
./setup.sh

Talvez leve alguns minutos para o script ser executado.

Crie um cluster do GKE

Agora que seu ambiente para desenvolvedores está funcionando, você precisa de um cluster do Kubernetes para implantar o aplicativo monolítico e depois os microsserviços. Antes de criar um cluster, veja se as APIs corretas estão ativadas.

Execute o comando a seguir para ativar a API Containers e usar o Google Kubernetes Engine:

gcloud services enable container.googleapis.com

Execute o comando abaixo para criar o cluster do GKE fancy-cluster com 3 nós:

gcloud container clusters create fancy-cluster --num-nodes 3

A criação do cluster talvez leve vários minutos.

Depois disso, execute este comando para ver as três instâncias da VM de worker do cluster:

gcloud compute instances list

Resposta:

NAME                                          ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
gke-fancy-cluster-default-pool-ad92506d-1ng3  us-central1-f  n1-standard-1               10.150.0.7   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4fvq  us-central1-f  n1-standard-1               10.150.0.5   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4zs3  us-central1-f  n1-standard-1               10.150.0.6   XX.XX.XX.XX    RUNNING

Também é possível visualizar o cluster do Kubernetes e as informações relacionadas no Console do Cloud. No Menu de navegação, role para baixo até Kubernetes Engine e clique em Clusters.

795c794b03c5d2b0.png

O cluster chamado fancy-cluster deve aparecer aqui.

6b394dfb8a6031f2.png

Parabéns! Você acabou de criar seu primeiro cluster do Kubernetes.

Clique em Verificar meu progresso para conferir o objetivo. Crie um cluster do GKE

Implante um aplicativo monolítico pronto

Neste laboratório, você precisará instalar e executar um aplicativo monolítico para poder dividi-lo em microsserviços.

Execute o script a seguir para implantar um aplicativo monolítico no seu cluster do GKE:

cd ~/monolith-to-microservices
./deploy-monolith.sh

Como acessar o aplicativo monolítico

Para localizar o endereço IP externo do aplicativo monolítico, execute o seguinte comando:

kubectl get service monolith

A resposta será parecida com esta:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
monolith     10.3.251.122    203.0.113.0     80:30877/TCP     3d

Caso sua resposta liste o endereço IP como <pending> espere um minuto e execute o comando outra vez.

Copie o endereço IP externo do aplicativo monolítico depois que ele aparecer. Cole o URL do IP externo (por exemplo, http://203.0.113.0) no navegador para verificar se o aplicativo monolítico está acessível.

f075aec979aaffc8.png

Você verá a página de boas-vindas do site monolítico, como mostra a imagem acima. A página de boas-vindas é estática e será apresentada pelo microsserviço Frontend depois. Agora seu aplicativo monolítico está sendo executado integralmente no Kubernetes.

Clique em Verificar meu progresso para conferir o objetivo. Implante um aplicativo monolítico pronto

Migre Orders para um microsserviço

Agora que o site monolítico está em execução no GKE, você já pode dividir cada serviço em um microsserviço. Em geral, é preciso fazer um planejamento para definir quais serviços serão divididos em blocos menores, normalmente relacionados a partes específicas do aplicativo, como o domínio comercial. Para este laboratório, você criará um exemplo e dividirá cada serviço no domínio comercial em: Orders, Products e Frontend. O código já foi migrado para você poder se concentrar na criação e na implantação dos serviços no Google Kubernetes Engine (GKE).

Crie o microsserviço Orders

O primeiro serviço a ser dividido é Orders. Use o codebase fornecido e crie um contêiner do Docker separado para esse serviço.

Crie um contêiner do Docker com o Cloud Build

Como você já tem o codebase, o primeiro passo é criar um contêiner do Docker para o serviço Orders usando o Cloud Build.

Em geral, esse processo tem duas etapas: criar o contêiner do Docker e enviá-lo para um registro, onde a imagem é armazenada e pode ser extraída pelo GKE. Com o Cloud Build, você pode criar o contêiner do Docker e mover a imagem para o Container Registry executando um único comando. Para ver o processo manual de criação e envio de um Dockerfile, clique aqui.

O Google Cloud Build compacta e envia os arquivos do diretório para um bucket do Cloud Storage. Todos os arquivos do bucket e o Dockerfile no mesmo diretório serão usados para executar o processo de compilação no Docker. A sinalização --tag é especificada com o host como gcr.io para a imagem do Docker. A imagem resultante do Docker será enviada ao Container Registry do Google Cloud.

Crie e envie seu contêiner do Docker para o Google Container Registry executando estes comandos:

cd ~/monolith-to-microservices/microservices/src/orders
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 .

O processo leva cerca de um minuto. Quando a compilação estiver pronta, o terminal mostrará o seguinte:

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID                                    CREATE_TIME                DURATION  SOURCE                                                                                  IMAGES                              STATUS
1ae295d9-63cb-482c-959b-bc52e9644d53  2019-08-29T01:56:35+00:00  33S       gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz  gcr.io/<PROJECT_ID>/orders:1.0.0  SUCCESS

Para visualizar seu histórico de builds ou o processo em tempo real, acesse o Console e clique no botão do __Menu de navegação__ no canto superior esquerdo. Depois role até "Ferramentas" e clique em Cloud Build > Histórico. Essa tela apresenta uma lista dos builds anteriores. Por enquanto, haverá apenas um (o que você acabou de criar).

4c753ede203255f6.png

Se clicar no ID do build, você verá todos os detalhes do build, inclusive a resposta do registro.

Na página de detalhes do build, clique na guia "Detalhes da execução" para visualizar a imagem do contêiner.

431b97d5293638da.png

Implante o contêiner no GKE

Agora que você já colocou o site em um contêiner e enviou o contêiner para o Google Container Registry, é hora de implantá-lo no Kubernetes.

O Kubernetes representa aplicativos como pods, que são unidades com um contêiner ou um grupo de contêineres estreitamente associados. O pod é a menor unidade implantável no Kubernetes. Neste tutorial, cada pod contém apenas o contêiner do seu microsserviço.

Para implantar e gerenciar aplicativos em um cluster do GKE, você precisa se comunicar com o sistema de gerenciamento de clusters do Kubernetes. A forma mais comum de fazer isso é usar a ferramenta de linha de comando kubectl no Cloud Shell.

Primeiro crie um recurso de implantação. Esse recurso gerencia diversas cópias do aplicativo, chamadas de réplicas. Ele programa as réplicas para serem executadas em nós individuais do cluster. Neste caso, a implantação executará apenas um pod do seu aplicativo. Para isso, o recurso de implantação cria um ReplicaSet. O ReplicaSet é responsável por garantir que as réplicas especificadas estejam sempre em execução.

O comando kubectl create deployment abaixo solicita que o Kubernetes crie uma implantação com o nome Orders no seu cluster com 1 réplica.

Execute o comando a seguir para implantar seu aplicativo:

kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0

Verifique a implantação

Para confirmar que a implantação foi criada, execute o seguinte comando:

kubectl get all

Talvez leve alguns instantes para o status do pod aparecer como "Running".

Resposta:

NAME                            READY   STATUS    RESTARTS   AGE
pod/monolith-779c8d95f5-dxnzl   1/1     Running   0          15h
pod/orders-5bc6969d76-kdxkk     1/1     Running   0          21s
NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
service/kubernetes   ClusterIP      10.39.240.1     <none>         443/TCP        19d
service/monolith     LoadBalancer   10.39.241.130   34.74.209.57   80:30412/TCP   15h
NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/monolith   1/1     1            1           15h
deployment.apps/orders     1/1     1            1           21s
NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/monolith-779c8d95f5   1         1         1       15h
replicaset.apps/orders-5bc6969d76     1         1         1       21s

Você pode ver a implantação atual, o replicaset com a contagem desejada de apenas 1 pod e o pod em execução. Parece que tudo foi criado corretamente.

Também é possível visualizar suas implantações do Kubernetes no Console do Cloud. Abra o Menu de navegação e selecione Kubernetes Engine > Cargas de trabalho.

Exponha o contêiner do GKE

Você implantou o aplicativo no GKE, mas não é possível acessá-lo de fora do cluster. Por padrão, os contêineres executados no GKE não podem ser acessados pela Internet porque não têm endereços IP externos. Exponha explicitamente o aplicativo ao tráfego da Internet usando o recurso Serviço. Esse serviço dá suporte de rede e IP aos pods do seu aplicativo. O GKE cria um IP externo e um balanceador de carga, sujeito a faturamento, para seu aplicativo.

Para este laboratório, a exposição do serviço foi simplificada. Normalmente você usaria um gateway de API para proteger seus endpoints públicos. Saiba mais sobre as práticas recomendadas para microsserviços.

Você usou uma implantação do Kubernetes para expor internamente o serviço Orders na porta 8081. Para expor Orders externamente, é preciso criar um serviço do Kubernetes do tipo LoadBalancer que encaminha o tráfego da porta 80 externamente para a porta interna 8081.

Execute o comando a seguir para expor o site à Internet:

kubectl expose deployment orders --type=LoadBalancer --port 80 --target-port 8081

Como acessar o serviço

O GKE atribui o endereço IP externo ao serviço, não à implantação. Se você quer descobrir o IP externo provisionado pelo GKE para o aplicativo, inspecione o serviço com o comando kubectl get service:

kubectl get service orders

Resposta:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
orders       10.3.251.122    203.0.113.0     80:30877/TCP     3s

Copie o endereço IP externo do aplicativo depois que ele aparecer. Você precisará dele na próxima etapa, quando alterar seu aplicativo monolítico para apontar para o novo serviço Orders.

Reconfigure o aplicativo monolítico

Como você removeu o serviço Orders do aplicativo monolítico, será necessário modificá-lo para apontar para o novo microsserviço Orders externo.

Ao dividir um aplicativo monolítico, você está removendo partes do código de um único codebase para criar vários microsserviços que implantará separadamente. Como os microsserviços são executados em outro servidor, não é mais possível usar os URLs de serviço como caminhos absolutos. Você precisa direcionar para o endereço do servidor do microsserviço Orders. O aplicativo monolítico ficará inativo enquanto atualiza o URL de cada serviço que foi dividido. Leve isso em conta ao planejar a mudança dos microsserviços e do aplicativo monolítico para produção, durante o processo de migração dos microsserviços.

Agora você precisa atualizar o arquivo de configuração no aplicativo monolítico para apontar para o endereço IP do novo microsserviço Orders. Use o editor nano para substituir o URL local pelo endereço IP do microsserviço Orders:

cd ~/monolith-to-microservices/react-app
nano .env.monolith

Quando o editor é aberto, aparece um arquivo semelhante a este:

REACT_APP_ORDERS_URL=/service/orders
REACT_APP_PRODUCTS_URL=/service/products

Substitua REACT_APP_ORDERS_URL pelo novo formato, mudando os endereços IP do microsserviço Orders para corresponder a:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=/service/products

Pressione CTRL+O, ENTER e CTRL+X para salvar o arquivo no editor nano.

Para testar o novo microsserviço, acesse o URL que você configurou no arquivo. A página da Web deve retornar uma resposta JSON do seu microsserviço Orders.

O próximo passo é recriar o Frontend do aplicativo monolítico. Repita o processo para criar o contêiner do aplicativo monolítico e reimplantá-lo no cluster do GKE.

Recrie os arquivos de configuração do aplicativo monolítico

npm run build:monolith

Crie o contêiner do Docker com o Cloud Build:

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

Implante o contêiner no GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

Verifique se o aplicativo está acessando o microsserviço Orders. Para isso, visite a página Orders do aplicativo monolítico pelo navegador. Todos os IDs de pedidos devem terminar com o sufixo -MICROSERVICE, como na imagem abaixo:

1cdd60bb0d4d1148.png

Clique em Verificar meu progresso para conferir o objetivo. Migre Orders para um microsserviço

Migre Products para um microsserviço

Crie o microsserviço Products

Migre Products para continuar dividindo os serviços. Repita o processo anterior. Execute os comandos a seguir para criar um contêiner do Docker e depois implantar e expor esse contêiner usando um serviço do Kubernetes.

Crie o contêiner do Docker com o Cloud Build:

cd ~/monolith-to-microservices/microservices/src/products
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .

Implante o contêiner no GKE:

kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0

Exponha o contêiner do GKE:

kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082

Encontre o IP público do serviço Products como você fez com o serviço Orders:

kubectl get service products

Resposta:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
products     10.3.251.122    203.0.113.0     80:30877/TCP     3d

Você usará o endereço IP na próxima etapa ao reconfigurar o aplicativo monolítico para apontar para o novo microsserviço Products.

Reconfigure o aplicativo monolítico

Use o editor nano para substituir o URL local pelo endereço IP do novo microsserviço Products:

cd ~/monolith-to-microservices/react-app
nano .env.monolith

Quando o editor é aberto, aparece um arquivo semelhante a este:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=/service/products

Substitua REACT_APP_PRODUCTS_URL pelo novo formato e mude o endereço IP do microsserviço Products para corresponder a:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=http://<PRODUCTS_IP_ADDRESS>/api/products

Pressione CTRL+O, ENTER e CTRL+X para salvar o arquivo.

Para testar o novo microsserviço, acesse o URL que você configurou no arquivo. A página da Web deve retornar uma resposta JSON do microsserviço Products.

O próximo passo é recriar o Frontend do aplicativo monolítico. Repita o processo para criar o contêiner do aplicativo monolítico e reimplantá-lo no cluster do GKE. Execute os seguintes comandos para concluir as etapas abaixo.

Recrie os arquivos de configuração do aplicativo monolítico:

npm run build:monolith

Crie o contêiner do Docker com o Cloud Build:

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .

Implante o contêiner no GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0

Verifique se o aplicativo está acessando o novo microsserviço Products. Para isso, visite a página Products do aplicativo monolítico pelo navegador. Todos os nomes de produto devem ter o prefixo MS-, como nas imagens abaixo:

5389b29f4b8c7c69.png

Clique em Verificar meu progresso para conferir o objetivo. Migre Products para um microsserviço

Migre Frontend para um microsserviço

A última etapa do processo de migração é mover o código de Frontend para um microsserviço e desativar o aplicativo monolítico. Quando essa etapa for concluída, o aplicativo monolítico terá sido migrado para uma arquitetura de microsserviços.

Crie o microsserviço Frontend

Siga o mesmo procedimento das últimas duas etapas para criar o microsserviço Frontend.

Quando você recriou o aplicativo monolítico, atualizou a configuração para apontar para o aplicativo monolítico. Use a mesma configuração para o microsserviço Frontend.

Execute os comandos a seguir para copiar os arquivos de configuração de URL dos microsserviços para o codebase do microsserviço Frontend:

cd ~/monolith-to-microservices/react-app
cp .env.monolith .env
npm run build

Quando terminar, repita o processo das etapas anteriores. Execute os comandos a seguir para criar um contêiner do Docker e depois implantar e expor esse contêiner usando um serviço do Kubernetes.

Crie um contêiner do Docker com o Google Cloud Build:

cd ~/monolith-to-microservices/microservices/src/frontend
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0 .

Implante o contêiner no GKE:

kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0

Exponha o contêiner do GKE

kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080

Clique em Verificar meu progresso para conferir o objetivo. Migre Frontend para um microsserviço

Exclua o aplicativo monolítico

Agora que todos os serviços estão sendo executados como microsserviços, você já pode excluir o aplicativo monolítico. Em uma migração real, outras mudanças seriam necessárias, como alterar o DNS para os nomes de domínio atuais apontarem para o novo microsserviço Frontend do aplicativo.

Execute os comandos abaixo para excluir o aplicativo monolítico:

kubectl delete deployment monolith
kubectl delete service monolith

Teste seu trabalho

Se tudo estiver operando corretamente, o endereço IP antigo do serviço do aplicativo monolítico não deve funcionar mais. O novo endereço IP agora hospeda o serviço Frontend. Para ver uma lista com todos os serviços e endereços IP, execute o seguinte comando:

kubectl get services

A resposta será semelhante a:

NAME         TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
frontend     LoadBalancer   10.39.246.135   35.227.21.154    80:32663/TCP   12m
kubernetes   ClusterIP      10.39.240.1     <none>           443/TCP        18d
orders       LoadBalancer   10.39.243.42    35.243.173.255   80:32714/TCP   31m
products     LoadBalancer   10.39.250.16    35.243.180.23    80:32335/TCP   21m

Depois de determinar o endereço IP externo do microsserviço Frontend, copie o endereço IP. Acesse esse URL (por exemplo, http://203.0.113.0) no navegador para verificar se Frontend está acessível. Seu site deve ter a mesma aparência de antes da divisão do aplicativo monolítico em microsserviços.

Parabéns!

Você dividiu seu aplicativo monolítico em microsserviços e os implantou no Google Kubernetes Engine.

BuildingWebsitesOnGoogleCloud_125.png

Termine a Quest

Este laboratório autoguiado faz parte da Quest do Qwiklabs Website on Google Cloud. Uma Quest é uma série de laboratórios relacionados que formam um programa de aprendizado. Caso você já tenha feito este laboratório, inscreva-se nesta Quest para ganhar os créditos de conclusão imediatamente. Veja outras Quests do Qwiklabs.

Está procurando um laboratório com desafios práticos para demonstrar suas habilidades e conhecimentos? Quando terminar a Quest, faça este laboratório com desafiopara receber um selo digital exclusivo do Google Cloud.

Final_BuildWebsite.png

Comece o próximo laboratório

Continue seu aprendizado assistindo ao vídeo com o estudo de caso Hosting Scalable Web Applications on Google Cloud ou confira estas sugestões:

Próximas etapas / Recursos adicionais

Terminar o laboratório

Após terminar seu laboratório, clique em End Lab. O Qwiklabs removerá os recursos usados e limpará a conta para você.

Você poderá classificar sua experiência neste laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Submit.

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 Support.

Manual atualizado em 26 de maio de 2020
Laboratório testado em 23 de março de 2020

Copyright 2020 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.