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 este documento, confira se você conhece 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: |
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 |
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:
- Compute Engine instances used by GKE
- Spanner
- Cloud Load Balancing
Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.
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.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
Ativar as APIs
Enable the Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials 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.
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 apontarkubectl
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
porhello-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, oGSA_PROJECT
e o Google CloudPROJECT_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 CloudGSA_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 CloudPROJECT_ID
: o ID do projeto do Google CloudNAMESPACE
: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
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 camposerviceAccountName
substituindo<KSA_NAME>
porksa-helloapp
, o nome da sua conta de serviço do Kubernetes.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
porhello-namespace
.Aguarde até que o aplicativo seja implantado com
STATUS
comoRunning
:kubectl get pods -n=NAMESPACE --watch
Substitua
NAMESPACE
porhello-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
porhello-namespace
.Preste atenção ao endereço IP externo que será atribuído:
kubectl get service -n=NAMESPACE --watch
Substitua
NAMESPACE
porhello-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.
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.
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
porhello-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:
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.