Este laboratório foi desenvolvido com nosso parceiro, o MongoDB. Suas informações pessoais podem ser compartilhadas com o MongoDB, patrocinador do laboratório, caso você tenha optado por receber atualizações de produtos, anúncios e ofertas em seu perfil de conta.

GSP022

Visão geral

O Kubernetes é uma ferramenta de orquestração de contêineres de código aberto que lida com as complexidades da execução de aplicativos conteinerizados. É possível executar aplicativos do Kubernetes com o Kubernetes Engine, um serviço de computação do Google Cloud que conta com diferentes tipos de personalizações e integrações. Neste laboratório, você terá experiência prática com o Kubernetes ao aprender a configurar um banco de dados MongoDB com um StatefulSet. A execução de um aplicativo com estado (um banco de dados) em um serviço sem estado (contêiner) pode parecer contraditória. No entanto, depois deste laboratório, você descobrirá que não é bem assim. Com algumas ferramentas de código aberto, você verá como o Kubernetes e os serviços sem estado funcionam bem juntos.

Conteúdo do laboratório

Neste laboratório, você aprenderá o seguinte:

• Como implantar um cluster do Kubernetes, um serviço headless e um StatefulSet
• Como conectar um cluster do Kubernetes a um conjunto de réplicas do MongoDB
• Como fazer o escalonamento das instâncias do conjunto de réplicas do MongoDB para mais e para menos
• Como limpar o ambiente e encerrar os serviços acima

Pré-requisitos

Este é um laboratório de nível avançado. É recomendado ter conhecimento de Kubernetes ou aplicativos contenerizados. Também é desejável ter experiência com o Google Cloud Shell/SDK e o MongoDB. Se você quiser saber mais sobre esses serviços, confira os seguintes laboratórios:

• Kubernetes Engine: Qwik Start
• Como gerenciar implantações usando o Kubernetes Engine
• Datastore: Qwik Start

Quando estiver tudo pronto, role a tela para baixo e configure o ambiente do laboratório.

Configuração

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar 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, e 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 (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como começar o laboratório e fazer login no Console

1. Clique no botão Começar o laboratório. Se for preciso pagar pelo laboratório, você verá um pop-up para selecionar a forma de pagamento. Um painel é exibido à esquerda contendo as credenciais temporárias que você deve usar para o laboratório.

   

2. Copie o nome de usuário e clique em Abrir Console do Google. O laboratório inicia os recursos e depois abre a página Escolher uma conta em outra guia.

   Dica: abra as guias em janelas separadas, lado a lado.

3. Na página "Escolher uma conta", clique em Usar outra conta.

   

4. A página de login é aberta. Cole o nome de usuário que foi copiado do painel "Detalhes da conexão". Em seguida, copie e cole a senha.

   Importante: é preciso usar as credenciais do painel "Detalhes da conexão". Não use as credenciais do Qwiklabs. Não use sua conta pessoal do GCP, caso tenha uma, neste laboratório (isso evita cobranças).

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 avaliações gratuitas.

Depois de alguns instantes, o Console do GCP será aberto nesta guia.

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.

   

2. Clique em Continue (continuar):

   

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:

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:

Credentialed accounts:
- <myaccount>@<mydomain>.com (active)
	

Exemplo de saída:

Credentialed accounts:
- google1623327_student@qwiklabs.net
	

É 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
	

Tarefa 1: defina uma zona do Compute

No laboratório, usaremos a ferramenta de linha de comando gcloud para provisionar os serviços.

• Antes de criar o cluster do Kubernetes, precisamos definir uma zona do Compute para que todas as máquinas virtuais desse cluster sejam criadas na mesma região. É possível fazer isso com o comando gcloud config set. Execute o coamndo a seguir no Cloud Shell para definir a zona como :

gcloud config set compute/zone {{{project_0.default_zone | ZONE}}} Observação: saiba mais sobre regiões e zonas no Guia de regiões e zonas.

Tarefa 2: crie um novo cluster

Agora que já definimos a zona, criaremos um novo cluster de contêineres.

• Execute o seguinte comando para instanciar um cluster chamado hello-world:

gcloud container clusters create hello-world --num-nodes=2

Esse comando cria um cluster com dois nós ou máquinas virtuais. Você pode configurar o comando com mais sinalizações para alterar o número de nós, as permissões padrão e outras variáveis. Saiba mais na referência da gcloud para a criação de clusters de contêineres.

A inicialização do cluster pode levar alguns minutos. Assim que ele estiver pronto, você verá uma saída semelhante a esta:

NAME Location MATER_VERSION MASTER_IP ... hello-world {{{project_0.default_zone | ZONE}}} 1.9.7-gke.3 35.184.131.251 ...

Clique em Verificar meu progresso para conferir o objetivo.

Crie um novo cluster

Tarefa 3: hora da configuração

Agora que o cluster já está pronto, é hora de integrá-lo ao MongoDB. Usaremos um conjunto de réplicas para que os dados fiquem altamente disponíveis e redundantes, o que é essencial para executar aplicativos de produção.

Para começar a configurar, faça o seguinte:

• Faça o download do conjunto de réplicas/arquivo secundário do MongoDB (ou contêiner do utilitário do cluster).
• Instancie um StorageClass.
• Instancie um serviço headless.
• Instancie um StatefulSet.

1. Execute o seguinte comando para clonar o conjunto de réplicas do MongoDB/Kubernetes do repositório do GitHub:

gsutil -m cp -r gs://spls/gsp022/mongo-k8s-sidecar .

2. Depois da clonagem, navegue para o diretório StatefulSet com o seguinte comando:

cd ./mongo-k8s-sidecar/example/StatefulSet/

Depois de verificar se o download dos arquivos foi feito e se você está no diretório certo, é hora de criar um StorageClass do Kubernetes.

Crie o StorageClass

Um StorageClass indica ao Kubernetes que tipo de armazenamento você quer usar para os nós do banco de dados. No Google Cloud, você terá opções de armazenamento: SSDs e discos rígidos.

Se você acessar o conteúdo do diretório StatefulSet (é possível fazê-lo executando o comando ls), serão exibidos arquivos de configuração de SSD e HDD para o Azure e o Google Cloud.

1. Execute este comando para acessar o conteúdo do arquivo googlecloud_ssd.yaml:

cat googlecloud_ssd.yaml

Saída:

kind: StorageClass apiVersion: storage.k8s.io/v1beta1 metadata: name: fast provisioner: kubernetes.io/gce-pd parameters: type: pd-ssd

Essa configuração cria um novo StorageClass chamado "fast" que é baseado em volumes SSD.

2. Execute o seguinte comando para implantar o StorageClass:

kubectl apply -f googlecloud_ssd.yaml

Agora que o StorageClass está configurado, o StatefulSet já pode solicitar um volume que será criado automaticamente.

Clique em Verificar meu progresso para conferir o objetivo.

Crie o StorageClass

Tarefa 4: implante o serviço headless e o StatefulSet

Encontre e inspecione os arquivos

1. Antes de conferir mais detalhes sobre o serviço headless e os StatefulSets, abra o arquivo de configuração (mongo-statefulset.yaml) em que os dois estão hospedados:

nano mongo-statefulset.yaml

Você verá a seguinte saída (sem os ponteiros para o conteúdo do serviço headless e do StatefulSet):

apiVersion: v1 <----------- Headless Service configuration kind: Service metadata: name: mongo labels: name: mongo spec: ports: - port: 27017 targetPort: 27017 clusterIP: None selector: role: mongo --- apiVersion: apps/v1 <------- StatefulSet configuration kind: StatefulSet metadata: name: mongo spec: serviceName: "mongo" replicas: 3 selector: matchLabels: role: mongo template: metadata: labels: role: mongo environment: test spec: terminationGracePeriodSeconds: 10 containers: - name: mongo image: mongo command: - mongod - "--replSet" - rs0 - "--smallfiles" - "--noprealloc" ports: - containerPort: 27017 volumeMounts: - name: mongo-persistent-storage mountPath: /data/db - name: mongo-sidecar image: cvallance/mongo-k8s-sidecar env: - name: MONGO_SIDECAR_POD_LABELS value: "role=mongo,environment=test" volumeClaimTemplates: - metadata: name: mongo-persistent-storage annotations: volume.beta.kubernetes.io/storage-class: "fast" spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 50Gi

2. Remova as seguintes flags do arquivo (linhas 49 e 50):

- "--smallfiles" - "--noprealloc"

3. Verifique se esta seção do arquivo tem a seguinte aparência:

containers: - name: mongo image: mongo command: - mongod - "--replSet" - rs0 ports: - containerPort: 27017 volumeMounts: - name: mongo-persistent-storage mountPath: /data/db

4. Saia do editor nano pressionando CTRL+X > Y > ENTER.

Serviço headless: visão geral

A primeira parte do mongo-statefulset.yaml refere-se a um serviço headless. Em relação ao Kubernetes, um serviço descreve políticas ou regras para o acesso a pods específicos. Em resumo, um serviço headless não prescreve balanceamento de carga. Usado junto com StatefulSets, ele permite usar DNSs individuais para acessar os pods e ainda se conectar com todos os nós do MongoDB individualmente. No arquivo yaml, verifique se o campo clusterIP está definido como None para confirmar que o serviço é headless.

StatefulSet: visão geral

A configuração do StatefulSet é a segunda parte do mongo-statefulset.yaml. Ela é a base do aplicativo: a carga de trabalho que executa o MongoDB e os elementos responsáveis pela orquestração dos recursos do Kubernetes. Ao referenciar o arquivo yaml, vemos que o objeto StatefulSet é descrito na primeira parte dele. Depois, a seção de metadados especifica os rótulos e o número de réplicas.

O próximo ponto será a especificação do pod. O comando terminationGracePeriodSeconds será usado para encerrar normalmente o pod reduzindo o número de réplicas. A seguir, as configurações dos dois contêineres serão exibidas. O primeiro executa o MongoDB com flags de linha de comando que configuram o nome do conjunto de réplicas. Ele também ativa o volume de armazenamento permanente em /data/db, o local em que o MongoDB salva os dados. O segundo contêiner executa o arquivo secundário. Esse contêiner secundário irá configurar o conjunto de réplicas do MongoDB automaticamente. Como dito antes, um "arquivo secundário" é um contêiner auxiliar que ajuda o principal a executar jobs e tarefas.

Por fim, temos o volumeClaimTemplates. É ele que se comunica com o StorageClass que criamos antes para provisionar o volume. Ele provisiona um disco de 100 GB para cada réplica do MongoDB.

Implante o serviço headless e o StatefulSet

Agora que já temos noções básicas sobre o que é um serviço headless e um StatefulSet, vamos à implantação.

• Como os dois estão empacotados em mongo-statefulset.yaml, use o seguinte comando para executá-los:

kubectl apply -f mongo-statefulset.yaml

Você receberá esta saída:

service/mongo created statefulset.apps/mongo created

Clique em Verificar meu progresso para conferir o objetivo.

Implante o serviço headless e o StatefulSet

Tarefa 5: conecte-se ao conjunto de réplicas do MongoDB

Agora que temos um cluster em execução e o conjunto de réplicas implantado, a próxima etapa é conectar-se ao conjunto.

Aguarde até que o conjunto de réplicas do MongoDB seja totalmente implantado

Os StatefulSets do Kubernetes implantam cada pod sequencialmente. Ele espera até que o membro do conjunto de réplicas do MongoDB seja totalmente inicializado e cria o disco de backup antes de partir para o próximo membro.

• Execute este comando para ver e confirmar se os três membros foram criados:

kubectl get statefulset

A resposta indica que os três membros estão prontos:

NAME READY AGE mongo 3/3 103s

Inauguração e visualização do conjunto de réplicas do MongoDB

Neste ponto, você terá três pods criados no seu cluster. Estes correspondem aos três nodes no seu conjunto de réplicas do MongoDB.

1. Execute o comando a seguir para visualizá-los:

kubectl get pods

Saída:

NAME READY STATUS RESTARTS AGE mongo-0 2/2 Running 0 3m mongo-1 2/2 Running 0 3m mongo-2 2/2 Running 0 3m

2. Aguarde a criação dos três membros antes de continuar.

3. Conecte-se ao primeiro membro do conjunto de réplicas:

kubectl exec -ti mongo-0 -- mongosh

O ambiente REPL já está conectado ao MongoDB.

4. Instancie o conjunto de réplicas com uma configuração padrão executando o comando rs.initiate():

rs.initiate()

5. Imprima a configuração do conjunto de réplicas com o comando rs.conf():

rs.conf()

Essas saídas exibem os detalhes do membro atual do conjunto de réplicas rs0. Neste laboratório, só é possível ver um membro. Para receber detalhes de todos eles, é preciso expor o conjunto de réplicas usando outros serviços, como o NodePort ou o balanceador de carga.

rs0:OTHER> rs.conf() { "_id" : "rs0", "version" : 1, "protocolVersion" : NumberLong(1), "writeConcernMajorityJournalDefault" : true, "members" : [ { "_id" : 0, "host" : "localhost:27017", "arbiterOnly" : false, "buildIndexes" : true, "hidden" : false, "priority" : 1, "tags" : { }, "slaveDelay" : NumberLong(0), "votes" : 1 } ], "settings" : { "chainingAllowed" : true, "heartbeatIntervalMillis" : 2000, "heartbeatTimeoutSecs" : 10, "electionTimeoutMillis" : 10000, "catchUpTimeoutMillis" : -1, "catchUpTakeoverDelayMillis" : 30000, "getLastErrorModes" : { }, "getLastErrorDefaults" : { "w" : 1, "wtimeout" : 0 }, "replicaSetId" : ObjectId("5c526b6501fa2d29fc65c48c") } }

6. Digite "exit" e pressione Enter para sair do ambiente REPL.

Tarefa 6: escalone o conjunto de réplicas do MongoDB

Uma grande vantagem do Kubernetes e dos StatefulSets é a possibilidade de aumentar e diminuir o número de réplicas do MongoDB com um único comando.

1. Para ampliar o número de membros do conjunto de réplicas de três para cinco, execute este comando:

kubectl scale --replicas=5 statefulset mongo

Em alguns minutos, você terá cinco pods do MongoDB.

2. Execute este comando para visualizá-los:

kubectl get pods

A saída será parecida com esta:

NAME READY STATUS RESTARTS AGE mongo-0 2/2 Running 0 41m mongo-1 2/2 Running 0 39m mongo-2 2/2 Running 0 37m mongo-3 2/2 Running 0 4m mongo-4 2/2 Running 0 2m

3. Para reduzir o número de membros do conjunto de réplicas de cinco para três novamente, execute este comando:

kubectl scale --replicas=3 statefulset mongo

Em alguns segundos, haverá três pods do MongoDB.

4. Execute o comando a seguir para visualizá-los:

kubectl get pods

A saída será parecida com esta:

NAME READY STATUS RESTARTS AGE mongo-0 2/2 Running 0 41m mongo-1 2/2 Running 0 39m mongo-2 2/2 Running 0 37m

Clique em Verificar meu progresso para conferir o objetivo.

Escalone o conjunto de réplicas do MongoDB

Tarefa 7: use o conjunto de réplicas do MongoDB

Cada pod em um StatefulSet apoiado por um serviço headless terá um nome de DNS estável. O modelo segue este formato: <pod-name>.<service-name>

Isso significa que os nomes DNS do conjunto de réplicas do MongoDB são:

mongo-0.mongo mongo-1.mongo mongo-2.mongo

Use esses nomes diretamente no URI da string de conexão do seu aplicativo.

O uso do banco de dados está fora do escopo deste laboratório. Mesmo assim, neste caso, o URI da string de conexão seria:

"mongodb://mongo-0.mongo,mongo-1.mongo,mongo-2.mongo:27017/dbname_?"

Tarefa 8: hora de liberar espaço

Como você está trabalhando em um ambiente de laboratório, ao encerrar o laboratório, todos os recursos e o projeto serão limpos e descartados em seu nome. Mas queremos mostrar como você pode limpar recursos para reduzir custos e adotar boas práticas como de uso da nuvem quando estiver no seu próprio ambiente.

Para limpar os recursos implantados, execute os comandos a seguir para excluir o StatefulSet, o serviço headless e os volumes provisionados.

1. Exclua o StatefulSet:

kubectl delete statefulset mongo

2. Exclua o serviço:

kubectl delete svc mongo

3. Exclua os volumes:

kubectl delete pvc -l role=mongo

4. Por fim, você pode excluir o cluster de teste:

gcloud container clusters delete "hello-world"

5. Pressione Y e, em seguida, Enter para continuar e excluir o cluster de teste.

Parabéns!

Com o Kubernetes Engine, é possível executar contêineres no Google Cloud de maneira eficiente e flexível. Os StatefulSets permitem que você execute cargas de trabalho com estado como bancos de dados no Kubernetes. Em resumo, você aprendeu:

• Como criar um conjunto de réplicas do MongoDB com StatefulSets do Kubernetes
• Como conectar-se ao conjunto de réplicas do MongoDB
• Como escalonar o conjunto de réplicas

Finalize sua Quest

Este laboratório autoguiado faz parte da Quest de Arquitetura de nuvem. Uma Quest é uma série de laboratórios relacionados que formam um programa de aprendizado. Ao concluir uma, você ganha um distintivo pelo reconhecimento da sua conquista. É possível publicar os distintivos 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 Skills Boost para ver todas as Quests disponíveis.

Comece o próximo laboratório

Continue a Quest com o próximo laboratório ou confira estas sugestões:

• App da Web para análises de dados em tempo real com Kubernetes, Redis e BigQuery
• Orquestração na nuvem com o Kubernetes

Próximas etapas/Saiba mais

• Saiba mais sobre o Kubernetes Engine.
• Leia a postagem do blog sobre Como executar o MongoDB no Kubernetes com o StatefulSets (em inglês).
• Quer saber quanto custará para executar suas cargas de trabalho? Confira a calculadora de preços. Você pode inserir o número de instâncias, a vCPU e os requisitos de memória.
• Ganhe US$ 500 de crédito para o MongoDB sem custos no Google Cloud Marketplace (aplicável apenas para novos clientes).

Treinamento e certificação do Google Cloud

...ajuda você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações ajudam você a validar e comprovar suas habilidades e conhecimentos das tecnologias do Google Cloud.

Última atualização do manual em 9 de outubro de 2023

Último teste do laboratório em 9 de outubro de 2023

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