Esta página foi traduzida pela API Cloud Translation.

Percurso de aprendizagem: aplicações escaláveis – Crie um cluster

Autopilot

Este conjunto de tutoriais destina-se a administradores de TI e operadores que querem implementar, executar e gerir ambientes de aplicações modernos que são executados no Google Kubernetes Engine (GKE). À medida que avança neste conjunto de tutoriais, vai aprender a configurar a monitorização e os alertas, dimensionar cargas de trabalho e simular falhas, tudo isto usando a aplicação de microsserviços de exemplo do Cymbal Bank:

Crie um cluster e implemente uma aplicação de exemplo (este tutorial)
Monitorize com o serviço gerido do Google Cloud para Prometheus
Dimensione cargas de trabalho
Simule uma falha
Centralize a gestão da mudança

Vista geral e objetivos

O Cymbal Bank usa Python e Java para executar os vários serviços e inclui um back-end PostgreSQL. Não precisa de ter experiência com estas linguagens ou plataforma de base de dados para concluir a série de tutoriais, uma vez que o Cymbal Bank é apenas uma aplicação de exemplo para mostrar como o GKE pode suportar as necessidades da sua empresa.

Neste tutorial, vai aprender a criar um único cluster do GKE e a implementar uma aplicação de exemplo baseada em microsserviços denominada Cymbal Bank num cluster do GKE. Aprende a concluir as seguintes tarefas:

Crie um cluster do GKE que use o Autopilot.
Implemente uma aplicação de exemplo baseada em microsserviços denominada Cymbal Bank.
Use a Google Cloud consola para explorar os recursos do GKE usados pela aplicação de exemplo do Cymbal Bank.

Custos

A ativação do GKE e a implementação da aplicação de exemplo do Cymbal Bank para esta série de tutoriais significa que incorre em custos por cluster para o GKE on Google Cloud , conforme indicado na nossa página de preços, até desativar o GKE ou eliminar o projeto.

Também é responsável por outros Google Cloud custos incorridos durante a execução da aplicação de exemplo do Cymbal Bank, como encargos de VMs do Compute Engine e equilibradores de carga.

Antes de começar

Neste primeiro tutorial da série, conclua todos os passos de configuração "Comece já" antes de começar. Só tem de concluir os passos "Antes de começar" seguintes uma vez.

Configure a shell e as ferramentas

Nesta série de tutoriais, vai usar as seguintes ferramentas para implementar e gerir o seu ambiente:

CLI gcloud: crie e faça a gestão de clusters e frotas do GKE, juntamente com outros Google Cloud serviços.
kubectl: gerir o Kubernetes, o sistema de orquestração de clusters usado pelo GKE.

Para executar os comandos nesta página, configure a Google Cloud CLI e o kubectl num dos seguintes ambientes de desenvolvimento:

Cloud Shell

Para usar um terminal online com a CLI gcloud e o kubectl já configurados, ative o Cloud Shell:

Na parte inferior desta página, é iniciada uma sessão do Cloud Shell e é apresentado um pedido de linha de comandos. A sessão pode demorar alguns segundos a ser inicializada.

Shell local

Para usar um ambiente de desenvolvimento local, siga estes passos:

Instale a CLI gcloud.
Inicialize a CLI gcloud.
Instale kubectl a CLI gcloud:
```
gcloud components install kubectl
```

Configure o seu projeto

Siga os passos abaixo para configurar um projeto do Google Cloud , incluindo a ativação da faturação e dos serviços do GKE. Este é o projeto onde vai ativar o GKE.

Pode precisar de um Google Cloud administrador na sua organização para lhe conceder acesso para criar ou usar um projeto e ativar APIs.

Na Google Cloud consola, aceda à página Google Kubernetes Engine:

Aceda à página do Google Kubernetes Engine
Crie ou selecione um projeto. Este é o projeto onde ativa o GKE.
Se lhe for pedido, ative a API GKE.
Aguarde até que a API e os serviços relacionados sejam ativados. Este processo pode demorar vários minutos.
Verify that billing is enabled for your Google Cloud project.

Conceda funções de IAM

Se for o proprietário do projeto (por exemplo, se tiver criado o projeto), já tem todas as autorizações necessárias para concluir estes tutoriais. Se não for o proprietário, certifique-se de que a sua conta tem as funções do IAM necessárias para o projeto selecionado para este conjunto de tutoriais. Google Cloud Mais uma vez, pode precisar de um administrador na sua organização para ajudar a conceder as funções necessárias.Google Cloud

Nos comandos seguintes, substitua PROJECT_ID pelo ID gerado automaticamente do projeto que criou ou selecionou na secção anterior. O ID do projeto é frequentemente diferente do nome do projeto. Por exemplo, o seu projeto pode ser scalable-apps, mas o ID do projeto pode ser scalable-apps-567123.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/resourcemanager.projectIamAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/logging.logWriter, roles/gkehub.admin, roles/viewer, roles/monitoring.viewer

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

Replace the following:

PROJECT_ID: your project ID.
USER_IDENTIFIER: the identifier for your user account—for example, myemail@example.com.
ROLE: the IAM role that you grant to your user account.

Clone a aplicação de exemplo

Clone o repositório Git que inclui todos os manifestos de exemplo para o Cymbal Bank:

  git clone https://github.com/GoogleCloudPlatform/bank-of-anthos
  cd bank-of-anthos/

Crie um cluster

Com todos os passos prévios nas secções anteriores concluídos, pode começar a criar um cluster do GKE e implementar uma aplicação de exemplo.

O GKE é um serviço Kubernetes gerido que pode usar para implementar e operar aplicações contentorizadas. Um ambiente do GKE consiste em nós, que são máquinas virtuais (VMs) do Compute Engine, que são agrupadas para formar um cluster.

Crie um cluster do GKE que usa no resto dos tutoriais desta série:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION
```
Substitua o seguinte:
- PROJECT_ID com o ID gerado automaticamente do projeto que criou na secção anterior. O ID do projeto é frequentemente diferente do nome do projeto. Por exemplo, o seu projeto pode ser scalable-apps, mas o ID do projeto pode ser scalable-apps-567123.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Indique uma região, como us-central1.
Demora alguns minutos a criar o cluster e a verificar se tudo funciona corretamente.

Neste conjunto de tutoriais, usa clusters do modo Autopilot e alguns intervalos de endereços IP predefinidos quando cria clusters. Uma implementação de produção das suas próprias aplicações requer um planeamento mais cuidadoso do endereço IP. No modo Autopilot, a Google gere a configuração do cluster, incluindo o dimensionamento automático, a segurança e outras definições pré-configuradas. Os clusters no modo Autopilot são otimizados para executar a maioria das cargas de trabalho de produção e aprovisionar recursos de computação com base nos seus manifestos do Kubernetes.

Implemente o Cymbal Bank

As apps (também denominadas cargas de trabalho) são agrupadas em contentores. Implementa conjuntos de contentores como Pods nos seus nós.

Nesta série de tutoriais, implementa uma aplicação de exemplo baseada em microsserviços denominada Cymbal Bank num ou mais clusters do GKE. O Cymbal Bank usa Python e Java para executar os vários serviços e inclui um back-end PostgreSQL. Não precisa de ter experiência com estas linguagens ou plataforma de base de dados para concluir a série de tutoriais. O Cymbal Bank é apenas uma aplicação de exemplo para mostrar como o GKE pode suportar as necessidades da sua empresa.

Quando usa o Cymbal Bank como parte deste conjunto de tutoriais, os seguintes serviços são implementados no seu cluster do GKE:

Serviço	Idioma	Descrição
`frontend`	Python	Expõe um servidor HTTP para publicar o Website. Contém a página de início de sessão, a página de inscrição e a página inicial.
`ledger-writer`	Java	Aceita e valida as transações recebidas antes de as escrever no livro-razão.
`balance-reader`	Java	Fornece uma cache legível eficiente dos saldos dos utilizadores, conforme lidos a partir de `ledger-db`.
`transaction-history`	Java	Oferece uma cache legível eficiente de transações anteriores, conforme lidas a partir de `ledger-db`.
`ledger-db`	PostgreSQL	Livro de registo de todas as transações. Opção de pré-preenchimento com transações para utilizadores de demonstração.
`user-service`	Python	Gerir contas de utilizador e autenticação. Assina JWTs usados para autenticação por outros serviços.
`contacts`	Python	Armazena a lista de outras contas associadas a um utilizador. Usado para o menu pendente nos formulários "Enviar pagamento" e "Depósito".
`accounts-db`	PostgreSQL	Base de dados para contas de utilizador e dados associados. Opção de pré-preenchimento com utilizadores de demonstração.
`loadgenerator`	Python / Locust	Envia continuamente pedidos que imitam os utilizadores para o frontend. Cria periodicamente novas contas e simula transações entre elas.

Para implementar o Cymbal Bank no seu cluster do GKE, conclua os seguintes passos:

O Cymbal Bank usa símbolos da Web JSON (JWTs) para processar a autenticação do utilizador. Os JWTs usam pares de chaves assimétricas para assinar e validar tokens. No Cymbal Bank, userservice cria e assina tokens com uma chave privada RSA quando um utilizador inicia sessão, e os outros serviços usam a chave pública correspondente para validar o utilizador.

Crie um JWT RS256 com uma eficácia de 4096 bits:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Se necessário, transfira e instale as ferramentas OpenSSL para a sua plataforma.
Um segredo do Kubernetes pode armazenar dados confidenciais, como chaves ou palavras-passe. Os fluxos de trabalho executados no cluster podem, em seguida, aceder ao segredo para obter os dados confidenciais em vez de os codificar na aplicação.

Crie um segredo do Kubernetes a partir do ficheiro de chave que criou no passo anterior para o Cymbal Bank usar com pedidos de autenticação:
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

Implemente o Cymbal Bank no seu cluster. O comando seguinte implementa todos os ficheiros de manifesto no diretório kubernetes-manifests. Cada ficheiro de manifesto implementa 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

Pode ver mensagens na saída kubectl à medida que os manifestos são aplicados ao cluster sobre os limites do Autopilot. O Autopilot usa os pedidos de recursos que especifica na configuração da carga de trabalho para configurar os nós que executam as cargas de trabalho. O Autopilot aplica pedidos de recursos mínimos e máximos com base na classe de computação ou na configuração de hardware que as suas cargas de trabalho usam. Se não especificar pedidos para alguns contentores, o Autopilot atribui valores predefinidos para permitir que esses contentores sejam executados corretamente.

Reveja o seguinte manifesto de exemplo para o frontend Service:

# 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

Este manifesto para os frontend pedidos de serviço 100m de CPU e 64Mi, e define limites de 250m de CPU e 128Mi por pod.

Quando implementa uma carga de trabalho num cluster do Autopilot, o GKE valida a configuração da carga de trabalho em relação aos valores mínimos e máximos permitidos para a classe de computação ou a configuração de hardware selecionada (como GPUs). Se os seus pedidos forem inferiores ao mínimo, o Autopilot modifica automaticamente a configuração da carga de trabalho para colocar os pedidos dentro do intervalo permitido. Estas mensagens indicam que os limites adequados estão a ser atribuídos automaticamente.

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

kubectl get pods

A coluna STATUS muda de Pending para ContainerCreating. Demora alguns minutos até que todos os pods estejam no estado Running, conforme mostrado no seguinte exemplo de saída:

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, avance para o passo seguinte. Mais uma vez, demora alguns minutos até que todos os pods estejam no estado Running. É normal que alguns dos pods comuniquem um estado de READY0/1 até o Cymbal Bank estar pronto para publicar corretamente o tráfego.

O serviço frontend expõe um servidor HTTP para publicar o Website do Cymbal Bank, incluindo a página de início de sessão, a página de inscrição e a página inicial. Um objeto Ingress define regras para encaminhar tráfego HTTP(S) para aplicações em execução num cluster através de um Google Cloud balanceador de carga HTTP(S).

Obtenha o endereço IP externo do frontend Ingress:
```
kubectl get ingress frontend | awk '{print $4}'
```
Numa janela do navegador de Internet, abra o endereço IP apresentado no resultado do comando kubectl get ingress para aceder à sua instância do Cymbal Bank.

As credenciais predefinidas são preenchidas automaticamente, para que possa iniciar sessão na app e explorar algumas das transações e saldos de exemplo. Não tem de tomar medidas específicas, exceto confirmar que o Cymbal Bank é executado com êxito. Pode demorar um ou dois minutos até que todos os serviços estejam a comunicar corretamente e lhe permitam iniciar sessão.

Explore a sua implementação

Depois de criar um cluster do GKE e implementar cargas de trabalho, pode ter de alterar as definições ou rever o desempenho da sua aplicação. Nesta secção, vai aprender a usar a consola para rever os recursos que fazem parte do seu cluster e da aplicação de exemplo do Cymbal Bank. Google Cloud

Clusters

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

Na página do Google Kubernetes Engine da Google Cloud consola, aceda à página Clusters.

Aceda à página Clusters
Clique no cluster scalable-apps recentemente implementado. Na página de detalhes do cluster que é aberta, pode ver os detalhes básicos do cluster, juntamente com as configurações de rede e de segurança do cluster. Também pode ver que funcionalidades do GKE estão ativadas neste cluster na secção Funcionalidades.

Observabilidade

Pode ver métricas básicas sobre o estado e o desempenho do seu cluster. No próximo tutorial desta série, vai ativar o serviço gerido Google Cloud para Prometheus para uma monitorização e observabilidade mais detalhadas.

Selecione o cluster na página Clusters do Google Kubernetes Engine da Google Cloud consola e, de seguida, aceda ao separador Observabilidade.
Examine alguns dos gráficos de métricas para itens como a CPU e a memória. Esta vista permite-lhe monitorizar o desempenho das diferentes partes das cargas de trabalho do cluster sem ter de implementar capacidades de monitorização adicionais.
Para ver os registos transmitidos a partir do cluster, selecione o separador Registos. Pode filtrar por Gravidade dos registos ou criar os seus próprios filtros para ver espaços de nomes, serviços ou pods específicos. Tal como acontece com os avisos e os eventos de pods, esta vista agrupada dos registos do cluster pode ajudar a depurar problemas rapidamente através da consola Google Cloud .

É normal ver entradas de registo quando o Cymbal Bank é implementado pela primeira vez, quando alguns serviços ainda não conseguem comunicar.
Selecione o separador Erros da app. À medida que as cargas de trabalho são executadas, pode ver os avisos e os eventos reunidos na Google Cloud consola. Esta abordagem pode ajudar a resolver problemas sem ter de se ligar individualmente ao cluster, aos nós ou aos pods.

Mais uma vez, é normal ver eventos registados como Cymbal Bank quando alguns serviços ainda não conseguem comunicar.

Cargas de trabalho

A página do GKE da Google Cloud consola tem uma secção Cargas de trabalho que mostra uma vista agregada das cargas de trabalho executadas em todos os seus clusters do GKE.

Na página do Google Kubernetes Engine da Google Cloud consola, aceda à página Workloads

Aceda à página Cargas de trabalho

O separador Vista geral mostra uma lista de cargas de trabalho e namespaces do cluster do GKE. Pode filtrar por espaços de nomes para ver que cargas de trabalho são executadas em cada espaço de nomes.

Serviços e entrada

A vista Serviços e entrada mostra os recursos de serviço e entrada do projeto. Um serviço expõe um conjunto de pods como um serviço de rede com um ponto final, enquanto um Ingress gere o acesso externo aos serviços num cluster.

Na página do Google Kubernetes Engine da Google Cloud consola, aceda à página Gateways, Services & Ingress.

Aceda à página Gateways, serviços e entrada
Para encontrar a entrada do Cymbal Bank, clique no separador Entrada e encontre a entrada com o nome frontend. Um Ingress gere o tráfego de entrada para a sua aplicação. Pode ver informações sobre o balanceador de carga, as portas e os pontos finais externos.
Clique no endereço IP para a entrada frontend, como 198.51.100.143:80. Este endereço abre a interface Web do Cymbal Bank.

Limpar

O conjunto de tutoriais para o Cymbal Bank foi concebido para ser concluído um após o outro. À medida que avança no conjunto de tutoriais, aprende novas competências e usa Google Cloud produtos e serviços adicionais.

Se quiser fazer uma pausa antes de avançar para o tutorial seguinte e evitar incorrer em custos na sua Google Cloud conta pelos recursos usados neste tutorial Google Cloud , elimine o projeto que criou.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

O que se segue?

Saiba como monitorizar as suas cargas de trabalho no GKE através do serviço gerido da Google Cloud para Prometheus e do Cloud Monitoring no próximo tutorial.