Implantar um app usando o Autopilot do GKE e o Spanner

Autopilot

Neste tutorial, descrevemos como implantar um aplicativo da Web conteinerizado em um cluster do Autopilot do Google Kubernetes Engine (GKE) e usar um banco de dados do Google Spanner no back-end para armazenar dados. O aplicativo de amostra gerencia uma tabela de jogadores. Você pode adicionar e excluir jogadores por meio da interface gráfica do usuário (GUI, na sigla em inglês).

O Spanner é um serviço de banco de dados relacional totalmente gerenciado, escalonável horizontalmente e distribuído globalmente que fornece transações ACID e semântica SQL sem comprometer o desempenho e a alta disponibilidade.

Antes de ler esta página, você precisa ter familiaridade com o Kubernetes.

Por que o GKE e o Spanner

Como desenvolvedor, talvez você não queira gastar tempo identificando a quantidade de recursos de armazenamento e computação que seu aplicativo precisa, nem prevendo o consumo de RAM e CPU durante períodos de demanda instável ou se preocupando com falhas no aplicativo no pico de carga.

Ao usar o Autopilot do GKE como um serviço do Kubernetes totalmente gerenciado e o Spanner como um serviço de banco de dados totalmente gerenciado, é possível desenvolver e implantar apps mais rapidamente em uma infraestrutura estável que simplifica a configuração e o gerenciamento de recursos. O Autopilot do GKE processa a configuração e o escalonamento da infraestrutura para hospedar seu aplicativo adicionando nós ao cluster ou os removendo dele, com base nos requisitos do ambiente de execução. Da mesma forma, o Spanner pode ser escalonado dinamicamente com a intervenção manual mínima, à medida que os requisitos de armazenamento ou computação mudam.

Por exemplo, imagine que você esteja lançando um novo grande sucesso, um jogo que deverá ser viral e, portanto, vai atrair um tráfego intenso da Web durante a semana de lançamento. O Spanner pode ajudar você a atender essa capacidade de processamento de pico, permitindo que você aumente, diminua ou realoque recursos de computação instantaneamente, enquanto mantém a máxima disponibilidade de aplicativos com o Autopilot do GKE.

Objetivos

Neste tutorial, você aprenderá a realizar as seguintes tarefas:

Criar um banco de dados do Spanner que armazene um registro de jogadores.
Implantar um app da Web de amostra chamado hello-app-cloud-spanner, com uma interface gráfica do usuário.

A tabela a seguir descreve os recursos do Google Cloud que você cria ou usa, as variáveis com que são identificadas e os valores prescritos para elas no que diz respeito à finalidade deste tutorial:

Recurso	Variável	Valor
ID do projeto do Google Cloud	`PROJECT_ID`	O ID do projeto gerado quando você cria um projeto. Exemplo: `my-gcp-project`
Região do Compute	`COMPUTE_REGION`	A região do Compute Engine em que você quer criar a instância do Spanner e o cluster do GKE. Recomendamos que você escolha uma região mais próxima da localização geográfica dos seus clientes. No entanto, para fins deste tutorial, use `us-west1`.
Instância do Spanner	-	`hello-instance`
Banco de dados do Spanner	-	`hello-database`
Cluster do Autopilot do GKE	`CLUSTER_NAME`	`hello-cluster`
Namespace do Kubernetes	`NAMESPACE`	`hello-namespace`
Conta de serviço do Kubernetes	`KSA_NAME`	`ksa-helloapp`
Conta de serviço do IAM	`GSA_NAME`	`gsa-helloapp`
ID do projeto da conta de serviço do IAM	`GSA_PROJECT`	Seu `PROJECT_ID` do Google Cloud.

Para os fins deste tutorial, recomendamos a criação de novos recursos, pois isso facilita a exclusão deles e elimina os riscos posteriores à implantação do aplicativo de amostra. No entanto, se você já tiver namespaces, contas de serviço do IAM e contas de serviço do Kubernetes, poderá usá-los.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Siga os seguintes pré-requisitos:

Escolha ou crie um projeto

Você pode usar um projeto existente ou criar um novo para fins deste tutorial.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Ativar as APIs

Enable the Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials APIs.

Enable the APIs

Configurar o Cloud Shell

Neste tutorial, use o Cloud Shell para executar os comandos gcloud e kubectl. O Cloud Shell é um ambiente shell para gerenciar recursos hospedados no Google Cloud. Ele vem pré-instalado com a CLI do Google Cloud e a ferramenta de linha de comando kubectl.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console.

Antes de executar comandos neste tutorial, verifique se o projeto padrão está definido como ID do projeto em que você quer implantar o aplicativo de amostra. Execute o seguinte comando no Cloud Shell, caso ele ainda não esteja definido:

gcloud config set project PROJECT_ID

Substitua PROJECT_ID pelo ID do projeto.

Conceder papéis do IAM.

Verifique se sua conta do Google Cloud tem os papéis do IAM necessários para fins deste tutorial.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/iam.serviceAccountAdmin, roles/serviceusage.serviceUsageConsumer, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/spanner.admin, roles/container.admin

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

Replace PROJECT_ID with your project ID.
Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
Replace ROLE with each individual role.

Configurar o Spanner

Para configurar o Spanner, é necessário criar uma instância e um banco de dados do Spanner.

Criar uma instância do Spanner

Uma instância do Spanner é uma alocação de recursos usados pelos bancos de dados do Spanner criados nessa instância.

Crie uma instância do Spanner chamada hello-instance com uma configuração regional e calcule a capacidade de 100 unidades de processamento.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Substitua COMPUTE_REGION por us-west1 para fins deste tutorial.

Criar um banco de dados do Spanner

Um banco de dados do Spanner inclui tabelas, visualizações e índices. Um banco de dados herda propriedades da instância pai, como a configuração (regional ou multirregional), a capacidade de computação e armazenamento disponíveis.

Crie um banco de dados do Spanner chamado hello-database com uma tabela chamada Players, usando o dialeto GoogleSQL. Execute a consulta a seguir no Cloud Shell:

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Criar um cluster do Autopilot do GKE

Depois de configurar o Cloud Spanner, crie um cluster do Autopilot e use a federação de identidade da carga de trabalho do GKE para acessar seu banco de dados de maneira segura e gerenciável.

Crie um cluster do Autopilot chamado hello-cluster: Os clusters do Autopilot têm a federação de identidade da carga de trabalho do GKE ativada por padrão.

gcloud container clusters create-auto CLUSTER_NAME \
  --region=COMPUTE_REGION

Substitua:

CLUSTER_NAME: hello-cluster
COMPUTE_REGION: a região do Compute Engine do cluster. Para este tutorial, use a mesma região, us-west1, em que você criou a instância do Spanner. Recomendamos que você crie a instância do Spanner e o cluster do Autopilot do GKE na mesma região, para reduzir a latência.

A criação do cluster pode levar de 8 a 10 minutos.

O resultado será assim:

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Configurar o cluster para usar a federação de identidade da carga de trabalho para o GKE

Configure o cluster para se autenticar no Google Cloud usando a federação de identidade da carga de trabalho do GKE antes de implantar o app.

Obtenha credenciais para acessar seu cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --region=COMPUTE_REGION
```
Substitua:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1
Isso vai atualizar um arquivo kubeconfig com as credenciais e informações de endpoint apropriadas para apontar kubectl no cluster.
Crie o namespace que será usado para a conta de serviço do Kubernetes. Também é possível utilizar o namespace padrão ou qualquer namespace existente.
```
kubectl create namespace NAMESPACE
```
Substitua NAMESPACE por hello-namespace, o nome do novo namespace que você está criando.
Crie uma conta de serviço do Kubernetes para o aplicativo usar:
```
kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE
```
Substitua:
- KSA_NAME: ksa-helloapp, o nome da nova conta de serviço do Kubernetes que você está criando.
- NAMESPACE: hello-namespace
Crie uma conta de serviço do IAM para seu aplicativo:
```
gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT
```
Substitua:
- GSA_NAME: gsa-helloapp, o nome da nova conta de serviço do IAM que você está criando.
- GSA_PROJECT: é o ID do projeto do Google Cloud. Neste tutorial, você criará a conta de serviço do IAM no mesmo projeto do Google Cloud em que está implantando o aplicativo de amostra. Portanto, o GSA_PROJECT e o Google Cloud PROJECT_ID são iguais.

Adicione uma vinculação de política do IAM à conta de serviço do IAM para leitura e gravação no Spanner:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Substitua:

PROJECT_ID: o ID do projeto do Google Cloud
GSA_NAME: gsa-helloapp

Exemplo:

gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Permita a conta de serviço do Kubernetes atuar como a conta de serviço do IAM. Para isso, adicione uma vinculação de política do IAM entre as duas contas de serviço. Essa vinculação permite à conta de serviço do Kubernetes atue como a conta de serviço do IAM, para que a conta de serviço do Kubernetes possa ser lida e gravada no Spanner.
```
gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
```
Substitua:
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: o ID do projeto do Google Cloud
- PROJECT_ID: o ID do projeto do Google Cloud
- NAMESPACE: hello-namespace
- KSA_NAME: ksa-helloapp
Exemplo:
```
gcloud iam service-accounts add-iam-policy-binding gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"
```
Anote a conta de serviço do Kubernetes com o endereço de e-mail da conta de serviço do IAM. Isso permite que seu aplicativo de amostra identifique qual conta de serviço usar para acessar os serviços do Google Cloud. Portanto, quando o aplicativo usa qualquer biblioteca de cliente padrão da API do Google para acessar os serviços do Google Cloud, ele usa essa conta de serviço do IAM.
```
kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com
```
Substitua:
- KSA_NAME: ksa-helloapp
- NAMESPACE: hello-namespace
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: o ID do projeto do Google Cloud
Exemplo:
```
kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com
```
Observação: se a vinculação do IAM não existir, apenas essa anotação não concederá acesso ao pod para representar a conta de serviço do IAM.

Implantar o app de amostra no cluster

Agora que você configurou o GKE e o Spanner com os serviços e a autenticação necessários, tudo está pronto para implantar o aplicativo de amostra hello-app-cloud-spanner.

Clone o aplicativo de amostra do repositório do GitHub para o Cloud Shell:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Inicie o editor do Cloud Shell clicando em Abrir editor na barra de ferramentas da janela do terminal.

Para mais informações, consulte a Visão geral da interface do editor do Cloud Shell.
Abra o painel Explorer do editor do Cloud Shell e procure o diretório kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s.
Abra o arquivo deployment.yaml e atualize o campo serviceAccountName substituindo <KSA_NAME> por ksa-helloapp, o nome da sua conta de serviço do Kubernetes.

Figura 1. Atualize o nome da conta de serviço do Kubernetes no arquivo de implantação.
Feche o editor do Cloud Shell e volte ao terminal do Cloud Shell.
No terminal do Cloud Shell, procure o diretório hello-app-cloud-spanner:
```
cd kubernetes-engine-samples/databases/hello-app-cloud-spanner
```
Implante o aplicativo:
```
kubectl apply -f k8s/deployment.yaml -n=NAMESPACE
```
Substitua NAMESPACE por hello-namespace.

Aguarde até que o aplicativo seja implantado com STATUS como Running:

kubectl get pods -n=NAMESPACE --watch

Substitua NAMESPACE por hello-namespace.

O resultado será assim:

NAME                                       READY   STATUS              RESTARTS   AGE
hello-app-cloud-spanner-765c9b8779-lfcrc   0/1     ContainerCreating   0          87s
hello-app-cloud-spanner-765c9b8779-lfcrc   1/1     Running             0          3m15s

Pressione Ctrl+C no teclado para retornar ao prompt de comando e executar mais comandos.

Publicar o app de amostra na Internet

Para publicar um serviço do Kubernetes fora do cluster, crie um Serviço do tipo LoadBalancer. Esse tipo de serviço gera um endereço IP do balanceador de carga externo para os pods, que pode ser acessado pela Internet.

Implante o balanceador de carga:
```
kubectl apply -f k8s/service.yaml -n=NAMESPACE
```
Substitua NAMESPACE por hello-namespace.
Preste atenção ao endereço IP externo que será atribuído:
```
kubectl get service -n=NAMESPACE --watch
```
Substitua NAMESPACE por hello-namespace.
Depois de atribuído, copie o EXTERNAL-IP (por exemplo, 203.0.113.0) e abra-o em um navegador. É aberta uma interface da Web que exibe e gerencia o banco de dados dos jogadores.

É possível usar a GUI do app para criar ou excluir registros de um jogador. Eles ficam salvos no banco de dados do Spanner.

Adicionar ou excluir jogadores. — **Figura 2.** Criar ou excluir jogadores no registro.

Execute a consulta a seguir para verificar se o banco de dados do Spanner foi atualizado com as entradas:

gcloud spanner databases execute-sql hello-database \
  --instance=hello-instance \
  --sql="SELECT * FROM Players LIMIT 10"

O resultado será assim:

PlayerUuid: a1f34bbf-929c-498d-8b16-39bbb29d70e3
FirstName: John
LastName: Smith
BirthDate: 1997-07-12

PlayerUuid: d634e157-96ea-45f2-be3f-fb907ced188e
FirstName: Jane
LastName: Doe
BirthDate: 2013-07-12

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

A maneira mais fácil de evitar o faturamento é excluir o projeto criado para o tutorial.

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Se você tiver excluído o projeto, a limpeza estará completa. Se você não tiver excluído o projeto, apague os recursos do GKE e do Spanner.

Excluir recursos do GKE

Excluir o serviço: isso desaloca o balanceador de carga do Google Cloud criado para o serviço:
```
kubectl delete service hello-app-cloud-spanner -n=NAMESPACE
```
Substitua NAMESPACE por hello-namespace.
Exclua o cluster do GKE. Isso exclui os recursos que constituem um cluster, como instâncias de computação, discos e recursos de rede:
```
gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION
```
Substitua:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1

Excluir recursos do Spanner

Exclua o banco de dados do Spanner:

gcloud spanner databases delete hello-database --instance=hello-instance

Exclua a instância do Spanner:

Atenção: faz com que ela e todos os bancos de dados dela sejam removidos de forma permanente.
```
gcloud spanner instances delete hello-instance
```

A seguir

Saiba como criar um cluster do GKE para a instalação do Agones.
Conheça as práticas recomendadas para usar o Spanner como um banco de dados de jogos.
Saiba como implantar um banco de dados PostgreSQL de altamente disponível no GKE.
Conheça as práticas recomendadas para implantar bancos de dados no GKE.