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

Informações gerais

O Kubernetes é uma ferramenta de orquestração de contêineres de código aberto que lida com as complexidades da execução de aplicativos em contêiner. É possível executar aplicativos do Kubernetes com o Kubernetes Engine, um serviço de computação do Google Cloud que conta com muitas personalizações e integrações diferentes. 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. Ao usar 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 sem comando 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 em contêiner. 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.

Instalação

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, que é iniciado quando você clica em Start Lab, mostra por quanto tempo os recursos do 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 um ambiente simulado ou de demonstração. Isso é possível porque você recebe credenciais novas e temporárias para fazer login e acessar o Google Cloud Platform 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 todas as atividades.

Observação: não use um projeto seu nem uma conta pessoal do GCP neste laboratório.

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: definir uma zona do Compute

Durante este 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 seguinte 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: Criar 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 resposta 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. Como configurar

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 fazer a configuração, siga estas etapas:

• 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 sem comando.
• 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, acesse 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, há duas opções de armazenamento: SSDs e discos rígidos.

Se você acessar o conteúdo do diretório StatefulSet 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 sem comando e o StatefulSet

Encontre e inspecione os arquivos

1. Antes de conferir mais detalhes sobre o serviço sem comando 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 resposta (sem os ponteiros para o conteúdo do serviço sem comando 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 sem comando: visão geral

A primeira parte do mongo-statefulset.yaml refere-se a um serviço sem comando. 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 sem comando 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 é sem comando.

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.

Em seguida, há a especificação do pod. O comando terminationGracePeriodSeconds é usado para encerrar normalmente o pod ao reduzir o número de réplicas. Depois, são exibidas as configurações dos dois contêineres. O primeiro executa o MongoDB com sinalizações 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 de arquivo secundário irá configurar o conjunto de réplicas do MongoDB automaticamente. Como vimos antes, um "arquivo secundário" é um contêiner auxiliar que ajuda o principal a executar os 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 sem comando e o StatefulSet

Agora que temos uma ideia básica do que é um serviço sem comando e um StatefulSet, é hora da 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ê vai receber esta saída:

service/mongo created statefulset.apps/mongo created

Clique em Verificar meu progresso para conferir o objetivo.

Implante o serviço sem comando e o StatefulSet

Tarefa 5: conectar-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 é se conectar ao conjunto.

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

O StatefulSet do Kubernetes implanta cada pod sequencialmente. Ele espera até que o membro do conjunto de réplicas do MongoDB seja totalmente iniciado e cria o disco de apoio antes de iniciar 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

Iniciar e exibir o 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 este comando para ver:

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

Agora você tem um ambiente REPL 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()

Ele exibe os detalhes do membro atual do conjunto 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 do 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 vê-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, há três pods do MongoDB.

4. Execute este comando para ver:

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 sem comando terá um nome 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 (página em inglês) do 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: Limpar

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 a você como limpar recursos para economizar custos e ser um bom cidadão 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 sem comando 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. Você aprendeu o seguinte:

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

Termine a Quest

Este laboratório autoguiado faz parte da Quest Cloud Architecture. 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

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 dizer o número de instâncias, a vCPU e os requisitos de memória.
• Ganhe créditos de US$ 500 para o MongoDB sem custo financeiro 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.

Manual atualizado em 9 de outubro de 2023

Laboratório testado em 9 de outubro de 2023

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