arrow_back

Execute um banco de dados do MongoDB no Kubernetes com StatefulSets

Execute um banco de dados do MongoDB no Kubernetes com StatefulSets

1 hora 5 créditos

GSP022

Laboratórios autoguiados do Google Cloud

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 em contêiner. É possível executar aplicativos do Kubernetes com o Kubernetes Engine, um serviço de computação do GCP que conta com muitas personalizações e integrações diferentes. Neste laboratório, você terá uma experiência prática com o Kubernetes ao aprender a configurar um banco de dados do MongoDB com um StatefulSet (página em inglês). 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:

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

Configuração e requisitos

Configuração do Qwiklabs

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 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. Faremos isso usando o comando gcloud config set. Para definir a zona como us-central1-f, execute o seguinte no Cloud Shell:

gcloud config set compute/zone us-central1-f

Observação: veja mais informações sobre regiões e zonas.

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

Esse comando cria um novo cluster com três nós ou máquinas virtuais (o padrão). 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. Consulte a documentação para saber mais.

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  us-central1-f  1.9.7-gke.3     35.184.131.251  ...

Clique em Verificar meu progresso para verificar o objetivo.

Crie um novo cluster

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

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 .

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 Platform, 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, verá arquivos de configuração SSD e HDD para o Azure e o GCP. Execute este comando para ver o arquivo googlecloud_ssd.yaml:

cat googlecloud_ssd.yaml

Resposta:

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. 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 verificar o objetivo.

Crie o StorageClass

Implante o serviço sem comando e o StatefulSet

Encontre e inspecione os arquivos

Antes de vermos mais detalhes sobre serviço sem comando e 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: 100Gi

Remova os seguintes sinalizadores do arquivo (linhas 49 e 50):


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

Certifique-se que esta seção do seu arquivo parece com o seguinte:

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

Saia do editor do nano com 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.

A próxima parte é a especificação do pod. O terminationGracePeriodSeconds é usado para encerrar o pod quando o número de réplicas é reduzido. 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ê verá a seguinte resposta:

service "mongo" created
statefulset "mongo" created

Clique em Verificar meu progresso para verificar o objetivo.

Implante o serviço sem comando e o StatefulSet

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 é 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 crie 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

Resposta: os três membros estão prontos.

NAME      DESIRED   CURRENT   AGE
mongo     3         3         3m

Inicie e veja 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. Execute este comando para ver:

kubectl get pods

(Resposta):

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

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

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

kubectl exec -ti mongo-0 mongo

Agora você tem um ambiente REPL conectado ao MongoDB.

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

rs.initiate()

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")
        }
}

Digite "exit" e pressione Enter para sair de REPL.

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.

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. Execute este comando para vê-los:

kubectl get pods

A resposta 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

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. Execute este comando para ver:

kubectl get pods

A resposta 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 verificar o objetivo.

Escalone o conjunto de réplicas do MongoDB

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_?"

Limpeza

Como você está trabalhando no Qwiklabs, quando encerrar o laboratório, todos os seus recursos e seu projeto serão limpos e descartados no 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.

Exclua o StatefulSet:

kubectl delete statefulset mongo

Exclua o serviço:

kubectl delete svc mongo

Exclua os volumes:

kubectl delete pvc -l role=mongo

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

gcloud container clusters delete "hello-world"

Pressione Y e Enter para continuar excluindo o cluster de teste.

Parabéns!

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

O que vimos

  • 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

ac89564fa3705b3a.png Solutions_Kubernetes-125.png

Termine a Quest

Este laboratório autoguiado faz parte das Quests do Qwiklabs Cloud Architecture e Kubernetes Solutions. Uma Quest é uma série de laboratórios relacionados que formam um programa de aprendizado. Concluir esta Quest dá a você o selo acima como reconhecimento da sua conquista. Você pode publicar os selos e incluir um link para eles no seu currículo on-line ou nas redes sociais. Caso você já tenha feito este laboratório, inscreva-se em uma Quest para ganhar os créditos de conclusão imediatamente. Veja outras Quests do Qwiklabs disponíveis.

Comece o próximo laboratório

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

Próximas etapas / Saiba mais

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 01 de novembro de 2020
Laboratório testado em 01 de novembro 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.