Esta página foi traduzida pela API Cloud Translation.

Programa de aprendizado: aplicativos escalonáveis - Criar um cluster

Este conjunto de tutoriais é destinado a administradores e operadores de TI que querem implantar, executar e gerenciar ambientes de aplicativos modernos executados no Google Kubernetes Engine (GKE). À medida que avança neste conjunto de tutoriais, você aprende a configurar o monitoramento e alertas, escalonar cargas de trabalho e simular falhas. Tudo isso usando o aplicativo de microsserviços de exemplo Cymbal Bank:

Criar um cluster e implantar um aplicativo de amostra (este tutorial)
Monitorar com o Google Cloud Managed Service para Prometheus
Escalonar cargas de trabalho
Simular uma falha
Centralizar a gestão da mudança

Visão geral e objetivos

O Cymbal Bank usa Python e Java para executar os diversos serviços e inclui um back-end PostgreSQL. Você não precisa ter experiência com essas linguagens ou plataformas de banco de dados para concluir a série de tutoriais, já que o Cymbal Bank é apenas um exemplo de aplicativo para mostrar como o GKE pode atender às necessidades da sua empresa.

Neste tutorial, você aprenderá a criar um único cluster do GKE e implantar um aplicativo de amostra baseado em microsserviços chamado Cymbal Bank em um cluster do GKE. Você aprenderá a concluir as seguintes tarefas:

Criar um cluster do GKE que usa o Autopilot.
Implantar um aplicativo de amostra baseado em microsserviços chamado Cymbal Bank.
Use o console Google Cloud para conhecer os recursos do GKE usados pelo aplicativo de amostra Cymbal Bank.

Criar um cluster

Com todas as etapas de pré-requisito das seções anteriores concluídas, agora você pode começar a criar um cluster do GKE e implantar um aplicativo de amostra.

O GKE é um serviço gerenciado do Kubernetes que pode ser usado para implantar e operar aplicativos conteinerizados. Um ambiente do GKE consiste em nós, que são máquinas virtuais (VMs) do Compute Engine, agrupadas para formar um cluster.

Crie um cluster do GKE para usar nos outros tutoriais desta série:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION
```
Substitua:
- PROJECT_ID pelo ID gerado automaticamente do projeto que você criou na seção anterior. O ID do projeto costuma ser diferente do nome do projeto. Por exemplo, seu projeto pode ser scaleble-apps, mas o ID do projeto pode ser scaleble-apps-567123.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controle do cluster. Forneça uma região, como us-central1.
O GKE leva alguns minutos para criar o cluster e verificar se tudo funciona corretamente.

Neste conjunto de tutoriais, você usa clusters no modo Autopilot e alguns intervalos de endereços IP padrão ao criar clusters. Uma implantação de produção dos próprios aplicativos requer um planejamento de endereço IP mais cuidadoso. No modo Autopilot, o Google gerencia a configuração do cluster, incluindo escalonamento automático, segurança e outras configurações pré-configuradas. Os clusters no modo Autopilot são otimizados para executar a maioria das cargas de trabalho de produção e provisionar recursos de computação com base nos seus manifestos do Kubernetes.

Implantar o Cymbal Bank

Empacote os aplicativos (também chamados de cargas de trabalho) em contêineres. Implante conjuntos de contêineres como pods nos nós.

Nesta série de tutoriais, você implantará um aplicativo de amostra baseado em microsserviços chamado Cymbal Bank em um ou mais clusters do GKE. O Cymbal Bank usa Python e Java para executar os diversos serviços e inclui um back-end PostgreSQL. Você não precisa ter experiência com essas linguagens ou plataformas de banco de dados para concluir a série de tutoriais. O Cymbal Bank é apenas um exemplo de aplicativo mostrar como o GKE atende às necessidades da sua empresa.

Ao usar o Cymbal Bank como parte deste conjunto de tutoriais, os seguintes serviços serão implantados no seu cluster do GKE:

Serviço	Idioma	Descrição
`frontend`	Python	Expõe um servidor HTTP para exibir o site. Contém a página de login, a página de inscrição e a página inicial.
`ledger-writer`	Java	Aceita e valida transações de entrada antes de gravá-las no livro razão.
`balance-reader`	Java	Fornece um cache legível eficiente de saldos de usuários, conforme lido em `ledger-db`.
`transaction-history`	Java	Fornece um cache legível eficiente de transações anteriores, conforme lido em `ledger-db`.
`ledger-db`	PostgreSQL	Livro razão de todas as transações. Opção de pré-preencher com transações de usuários de demonstração.
`user-service`	Python	Gerencia contas de usuário e autenticação. Assina JWTs usados para autenticação por outros serviços.
`contacts`	Python	Armazena uma lista de outras contas associadas a um usuário. Usado como menu suspenso nos formulários "Enviar pagamento" e "Depósito".
`accounts-db`	PostgreSQL	Banco de dados para contas de usuário e dados associados. Opção de pré-preencher com usuários de demonstração.
`loadgenerator`	Python/Locust	Envia solicitações continuamente ao front-end, imitando usuários. Cria periodicamente novas contas e simula transações entre elas.

Para implantar o Cymbal Bank no seu cluster do GKE, conclua as seguintes etapas:

O Cymbal Bank usa JSON Web Tokens (JWTs) para processar a autenticação do usuário. Os JWTs usam pares de chaves assimétricas para assinar e verificar tokens. No Cymbal Bank, userservice cria e assina tokens com uma chave privada RSA quando um usuário faz login, e os outros serviços usam a chave pública correspondente para validar o usuário.

Crie um JWT RS256 com 4.096 bits de força:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Se necessário, baixe e instale as ferramentas do OpenSSL na sua plataforma.
Um secret do Kubernetes pode armazenar dados sensíveis, como chaves ou senhas. As cargas de trabalho que são executadas no cluster podem acessar o Secret para receber os dados sensíveis em vez de codificá-los no aplicativo.

Crie um Secret do Kubernetes pelo arquivo de chave criado na etapa anterior para o Cymbal Bank usar com solicitações de autenticação:
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

Implante o Cymbal Bank no seu cluster. O comando a seguir implanta todos os arquivos de manifesto no diretório kubernetes-manifests. Cada arquivo de manifesto implanta e configura um dos Serviços:

kubectl apply -f kubernetes-manifests/accounts-db.yaml
kubectl apply -f kubernetes-manifests/balance-reader.yaml
kubectl apply -f kubernetes-manifests/config.yaml
kubectl apply -f kubernetes-manifests/contacts.yaml
kubectl apply -f extras/postgres-hpa/kubernetes-manifests/frontend.yaml
kubectl apply -f kubernetes-manifests/ledger-db.yaml
kubectl apply -f kubernetes-manifests/ledger-writer.yaml
kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
kubectl apply -f kubernetes-manifests/transaction-history.yaml
kubectl apply -f kubernetes-manifests/userservice.yaml

É possível ver mensagens na saída do kubectl conforme os manifestos são aplicados ao cluster sobre os limites do Autopilot. O Autopilot usa as solicitações de recursos especificadas na configuração da carga de trabalho para configurar os nós que executam suas cargas de trabalho. O Autopilot aplica solicitações mínimas e máximas de recursos com base na classe de computação ou na configuração de hardware usada pelas suas cargas de trabalho. Se você não especificar solicitações para alguns contêineres, o Autopilot atribuirá valores padrão para permitir que eles sejam executados corretamente.

Analise o exemplo de manifesto a seguir para o Serviço frontend:

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: Service
metadata:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  ports:
    - name: http
      port: 80
      targetPort: 8080
  selector:
    app: frontend
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  selector:
    matchLabels:
      app: frontend
      application: bank-of-anthos
      environment: development
      team: frontend
      tier: web
  template:
    metadata:
      annotations:
        proxy.istio.io/config: '{ "holdApplicationUntilProxyStarts": true }'
      labels:
        app: frontend
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
    spec:
      containers:
        - env:
            - name: VERSION
              value: v0.6.7
            - name: PORT
              value: "8080"
            - name: ENABLE_TRACING
              value: "true"
            - name: SCHEME
              value: http
            - name: LOG_LEVEL
              value: info
            - name: DEFAULT_USERNAME
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_USERNAME
                  name: demo-data-config
            - name: DEFAULT_PASSWORD
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_PASSWORD
                  name: demo-data-config
            - name: REGISTERED_OAUTH_CLIENT_ID
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_CLIENT_ID
                  name: oauth-config
                  optional: true
            - name: ALLOWED_OAUTH_REDIRECT_URI
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_REDIRECT_URI
                  name: oauth-config
                  optional: true
          envFrom:
            - configMapRef:
                name: environment-config
            - configMapRef:
                name: service-api-config
          image: us-central1-docker.pkg.dev/bank-of-anthos-ci/bank-of-anthos/frontend:v0.6.7@sha256:6d92f3ce81a389738baf236477c6795831a0802c7a007697d7121f10eab9a2cc
          livenessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 15
            timeoutSeconds: 30
          name: front
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
            timeoutSeconds: 10
          resources:
            limits:
              cpu: 250m
              memory: 128Mi
            requests:
              cpu: 100m
              memory: 64Mi
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop:
                - all
            privileged: false
            readOnlyRootFilesystem: true
          volumeMounts:
            - mountPath: /tmp
              name: tmp
            - mountPath: /tmp/.ssh
              name: publickey
              readOnly: true
      securityContext:
        fsGroup: 1000
        runAsGroup: 1000
        runAsNonRoot: true
        runAsUser: 1000
      serviceAccountName: bank-of-anthos
      terminationGracePeriodSeconds: 5
      volumes:
        - emptyDir: {}
          name: tmp
        - name: publickey
          secret:
            items:
              - key: jwtRS256.key.pub
                path: publickey
            secretName: jwt-key

Esse manifesto para o serviço frontend solicita 100m de CPU e 64Mi e define limites de 250m de CPU e 128Mi por pod.

Quando você implanta uma carga de trabalho em um cluster Autopilot, o GKE valida a configuração da carga de trabalho com os valores mínimos e máximos permitidos para a classe de computação ou a configuração de hardware selecionadas (como GPUs). Se as solicitações forem menores que o mínimo, o Autopilot modificará automaticamente a configuração da carga de trabalho para colocar as solicitações no intervalo permitido. Essas mensagens indicam que os limites apropriados serão atribuídos automaticamente.

Aguarde até que os pods estejam prontos. Use kubectl para verificar o status dos pods:

kubectl get pods

A coluna STATUS muda de Pending para ContainerCreating. Leva alguns minutos para que todos os pods estejam em um estado Running, conforme mostrado no exemplo de saída a seguir:

NAME                                  READY   STATUS    RESTARTS   AGE
accounts-db-6f589464bc-6r7b7          1/1     Running   0          99s
balancereader-797bf6d7c5-8xvp6        1/1     Running   0          99s
contacts-769c4fb556-25pg2             1/1     Running   0          98s
frontend-7c96b54f6b-zkdbz             1/1     Running   0          98s
ledger-db-5b78474d4f-p6xcb            1/1     Running   0          98s
ledgerwriter-84bf44b95d-65mqf         1/1     Running   0          97s
loadgenerator-559667b6ff-4zsvb        1/1     Running   0          97s
transactionhistory-5569754896-z94cn   1/1     Running   0          97s
userservice-78dc876bff-pdhtl          1/1     Running   0          96s

Quando todos os pods estiverem no estado Running, prossiga para a próxima etapa. Novamente, leva alguns minutos para que todos os pods estejam em um estado Running. É normal que alguns dos pods informem um status READY de 0/1 até que o Cymbal Bank esteja pronto para atender o tráfego corretamente.

O serviço frontend expõe um servidor HTTP para exibir o site do Cymbal Bank, incluindo as páginas de login, de inscrição e inicial. Um objeto Ingress define regras para rotear o tráfego HTTP(S) para aplicativos em execução em um cluster usando um balanceador de carga HTTP(S) Google Cloud .

Encontre o endereço IP externo do Ingress frontend:
```
kubectl get ingress frontend | awk '{print $4}'
```
Em uma janela do navegador da Web, abra o endereço IP mostrado na saída do comando kubectl get ingress para acessar sua instância do Cymbal Bank.

As credenciais padrão são preenchidas automaticamente para que você possa fazer login no app e explorar algumas das transações e saldos de amostra. Nenhuma ação específica que você precisa tomar, além de confirmar se o Cymbal Bank é executado com sucesso. Pode levar um ou dois minutos para que todos os serviços estejam se comunicando corretamente e permitam que você faça login.

Explore a implantação

Depois de criar um cluster do GKE e implantar cargas de trabalho, talvez seja necessário alterar as configurações ou analisar o desempenho do aplicativo. Nesta seção, você vai aprender a usar o console Google Cloud para analisar os recursos que fazem parte do cluster e o aplicativo de amostra Cymbal Bank.

Clusters

Neste tutorial, você criou um cluster do GKE e implantou as cargas de trabalho do Cymbal Bank.

Na página do Google Kubernetes Engine do Google Cloud console, acesse a página Clusters.

Acessar a página de clusters
Clique no cluster scaleble-apps recém-implantado. Na página de detalhes do cluster aberta, é possível conferir os detalhes básicos, além das configurações de rede e segurança do cluster. Também é possível verificar quais recursos do GKE estão ativados nesse cluster na seção Recursos.

Observabilidade

É possível ver métricas básicas de integridade e desempenho do cluster. No próximo tutorial desta série, você ativará o Google Cloud Managed Service para Prometheus para monitoramento e observabilidade mais granulares.

Selecione o cluster na página Clusters do Google Kubernetes Engine no console doGoogle Cloud e acesse a guia Observabilidade.
Analise alguns gráficos das métricas relacionadas a CPU e memória, por exemplo. Essa visualização permite monitorar o desempenho de diferentes partes das cargas de trabalho do cluster sem precisar implantar outros recursos de monitoramento.
Para ver os registros transmitidos pelo cluster, selecione a guia Registros. É possível filtrar os registros por Gravidade ou criar seus próprios filtros para ver namespaces, Serviços ou pods específicos. Assim como acontece com os avisos e eventos de pods, essa visualização ordenada de registros do cluster pode ajudar a depurar problemas rapidamente usando o console do Google Cloud .

É normal ver entradas de registro, já que o Cymbal Bank é implantado pela primeira vez quando alguns serviços ainda não podem se comunicar.
Selecione a guia Erros do aplicativo. À medida que suas cargas de trabalho são executadas, é possível ver os avisos e eventos ordenados no console do Google Cloud . Essa abordagem pode ajudar a depurar problemas sem precisar se conectar individualmente ao cluster, aos nós ou aos pods.

Novamente, é normal ver eventos registrados, já que o Cymbal Bank é implantado pela primeira vez quando alguns Serviços ainda não podem se comunicar.

Cargas de trabalho

A página do GKE no console Google Cloud tem uma seção Cargas de trabalho que mostra uma visualização agregada das cargas de trabalho executadas em todos os clusters do GKE.

Na página do Google Kubernetes Engine no console do Google Cloud , acesse a página Cargas de trabalho.

Acessar a página "Cargas de trabalho"

A guia Visão geral mostra uma lista de cargas de trabalho e namespaces do cluster do GKE. É possível filtrar por namespaces para saber quais cargas de trabalho estão em execução em cada namespace.

Serviços e entrada

A visualização Serviços e Entrada mostra os recursos de serviço e de entrada do projeto. Um serviço expõe um conjunto de pods como um serviço de rede com um endpoint, enquanto um Ingress gerencia o acesso externo aos serviços em um cluster.

Na página do Google Kubernetes Engine do console Google Cloud , acesse Gateways, Serviços e Entrada.

Acessar a página "Gateways, Serviços e Ingress"
Para encontrar o entrada do Cymbal Bank, clique na guia Ingress e encontre a entrada com o nome frontend. Uma entrada gerencia o tráfego recebido do seu aplicativo. É possível ver informações sobre o balanceador de carga, as portas e os endpoints externos.
Clique no Endereço IP da entrada frontend, como 198.51.100.143:80. Esse endereço abre a interface da Web do Cymbal Bank.