arrow_back

Como implantar aplicativos do Spanner com o Cloud Run functions e o Cloud Run

Fazer login Inscreva-se
Acesse mais de 700 laboratórios e cursos

Como implantar aplicativos do Spanner com o Cloud Run functions e o Cloud Run

Laboratório 1 hora 30 minutos universal_currency_alt 1 crédito show_chart Introdutório
info Este laboratório pode incorporar ferramentas de IA para ajudar no seu aprendizado.
Acesse mais de 700 laboratórios e cursos

SCBL007

Visão geral

Neste laboratório, você vai criar aplicativos que usam bancos de dados do Spanner e implantá-los no Cloud Run functions e no Cloud Run. Você também vai instalar, configurar e ativar o emulador Spanner para uso em ambientes de desenvolvimento.

Objetivos

Neste laboratório, você vai aprender a:

  • Implantar o Cloud Run functions, que lê e grava em bancos de dados do Spanner.
  • Configurar e usar o emulador do Spanner para desenvolvimento.
  • Crie uma API REST que permita ler e gravar dados do Spanner.
  • Implantar uma API REST no Google Cloud Run.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

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 vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

  • Acesso a um navegador de Internet padrão (recomendamos o Chrome).
Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.
  • Tempo para concluir o laboratório: não se esqueça, depois de começar, não será possível pausar o laboratório.
Observação: não use seu projeto ou conta pessoal do Google Cloud neste laboratório para evitar cobranças extras.

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

Tarefa 1: criar um banco de dados com dados de teste

  1. Na barra de título do console do Google Cloud, clique em Ativar o Cloud Shell (Ícone do Cloud Shell). Caso solicitado, clique em Continuar. Se quiser, faça o mesmo selecionando a janela do Console do Cloud e digitando as teclas G e S no teclado.

  2. Execute o comando a seguir para ativar as APIs Cloud Build, Cloud Run e Event Arc. Se precisar autorizar o comando, faça isso.

gcloud services enable cloudbuild.googleapis.com gcloud services enable run.googleapis.com gcloud services enable eventarc.googleapis.com
  1. Execute o comando Bash a seguir para criar um arquivo de esquema para o banco de dados Pets.
mkdir ~/lab-files cd ~/lab-files cat > ./pets-db-schema.sql << ENDOFFILE CREATE TABLE Owners ( OwnerID STRING(36) NOT NULL, OwnerName STRING(MAX) NOT NULL ) PRIMARY KEY (OwnerID); CREATE TABLE Pets ( OwnerID STRING(36) NOT NULL, PetID STRING(MAX) NOT NULL, PetType STRING(MAX) NOT NULL, PetName STRING(MAX) NOT NULL, Breed STRING(MAX) NOT NULL, ) PRIMARY KEY (OwnerID,PetID), INTERLEAVE IN PARENT Owners ON DELETE CASCADE ENDOFFILE
  1. Execute os comandos a seguir para criar uma instância e um banco de dados do Spanner.
gcloud spanner instances create test-spanner-instance --config=regional-{{{project_0.default_region|place_holder_text}}} --description="test-spanner-instance" --processing-units=100 gcloud spanner databases create pets-db --instance=test-spanner-instance --database-dialect=GOOGLE_STANDARD_SQL --ddl-file=./pets-db-schema.sql
  1. Adicione alguns registros de teste ao banco de dados com os comandos a seguir.
owner_uuid=$(cat /proc/sys/kernel/random/uuid) gcloud spanner rows insert --table=Owners --database=pets-db --instance=test-spanner-instance --data=OwnerID=$owner_uuid,OwnerName=Doug gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Noir',PetType='Dog',Breed='Schnoodle' gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Bree',PetType='Dog',Breed='Mutt' gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Gigi',PetType='Dog',Breed='Retriever'

Tarefa 2: criar uma função do Cloud Run para leitura no Spanner

  1. Crie uma pasta para a primeira função do Cloud Run com o seguinte comando.
mkdir ~/lab-files/spanner_get_pets cd ~/lab-files/spanner_get_pets
  1. Crie dois arquivos para o aplicativo: main.py e requirements.txt.
touch main.py requirements.txt
  1. Clique no botão Abrir editor. No arquivo lab-files/spanner_get_pets/requirements.txt que você acabou de criar, adicione o código a seguir.
google-cloud-spanner==3.27.0
  1. No arquivo lab-files/spanner_get_pets/main.py, adicione o código a seguir, que lê do banco de dados e retorna os pets.
from google.cloud import spanner instance_id = 'test-spanner-instance' database_id = 'pets-db' client = spanner.Client() instance = client.instance(instance_id) database = instance.database(database_id) def spanner_get_pets(request): query = """SELECT OwnerName, PetName, PetType, Breed FROM Owners JOIN Pets ON Owners.OwnerID = Pets.OwnerID;""" outputs = [] with database.snapshot() as snapshot: results = snapshot.execute_sql(query) output = '<div>OwnerName,PetName,PetType,Breed</div>' outputs.append(output) for row in results: output = '<div>{},{},{},{}</div>'.format(*row) outputs.append(output) return '\n'.join(outputs)
  1. Clique no botão Abrir terminal. Depois, implante a função do Cloud Run com o seguinte comando. O gatilho será HTTP, o que significa que um URL será gerado para invocar a função. (A execução desse comando demora alguns minutos.)
gcloud functions deploy spanner_get_pets --runtime python310 --trigger-http --region={{{project_0.default_region|place_holder_text}}} --quiet
  1. Quando o comando de implantação da função do Cloud Run terminar, teste a função usando o comando a seguir. Os dados do teste devem ser retornados.
curl -m 70 -X GET https://{{{project_0.default_region|place_holder_text}}}-${GOOGLE_CLOUD_PROJECT}.cloudfunctions.net/spanner_get_pets -H "Authorization: bearer $(gcloud auth print-identity-token)" -H "Content-Type: application/json"

Tarefa 3: criar uma função do Cloud Run para gravar no Spanner

  1. Crie uma pasta para a segunda função do Cloud Run com o seguinte comando.
mkdir ~/lab-files/spanner_save_pets cd ~/lab-files/spanner_save_pets
  1. Crie dois arquivos para o aplicativo: main.py e requirements.txt.
touch main.py requirements.txt
  1. Clique no botão Abrir editor. No arquivo lab-files/spanner_save_pets/requirements.txt que você acabou de criar, adicione o código a seguir.
google-cloud-spanner==3.27.0
  1. No arquivo lab-files/spanner_save_pets/main.py, adicione o código a seguir, que lê do banco de dados e retorna os pets.
from google.cloud import spanner import base64 import uuid import json instance_id = 'test-spanner-instance' database_id = 'pets-db' client = spanner.Client() instance = client.instance(instance_id) database = instance.database(database_id) def spanner_save_pets(event, context): pubsub_message = base64.b64decode(event['data']).decode('utf-8') data = json.loads(pubsub_message) # Veja se o proprietário já existe with database.snapshot() as snapshot: results = snapshot.execute_sql(""" SELECT OwnerID FROM OWNERS WHERE OwnerName = @owner_name""", params={"owner_name": data["OwnerName"]}, param_types={"owner_name": spanner.param_types.STRING}) row = results.one_or_none() if row != None: owner_exists = True owner_id = row[0] else: owner_exists = False owner_id = str(uuid.uuid4()) # É preciso um UUID para o novo pet pet_id = str(uuid.uuid4()) def insert_owner_pet(transaction, data, owner_exists): try: row_ct = 0 params = { "owner_id": owner_id, "owner_name": data["OwnerName"], "pet_id": pet_id, "pet_name": data["PetName"], "pet_type": data["PetType"], "breed": data["Breed"], } param_types = { "owner_id": spanner.param_types.STRING, "owner_name": spanner.param_types.STRING, "pet_id": spanner.param_types.STRING, "pet_name": spanner.param_types.STRING, "pet_type": spanner.param_types.STRING, "breed": spanner.param_types.STRING, } # Adicione o proprietário somente se ele ainda não existir if not owner_exists: row_ct = transaction.execute_update( """INSERT Owners (OwnerID, OwnerName) VALUES (@owner_id, @owner_name)""", params=params, param_types=param_types,) # Adicione o pet row_ct += transaction.execute_update( """INSERT Pets (PetID, OwnerID, PetName, PetType, Breed) VALUES (@pet_id, @owner_id, @pet_name, @pet_type, @breed) """, params=params, param_types=param_types,) except: row_ct = 0 return row_ct row_ct = database.run_in_transaction(insert_owner_pet, data, owner_exists) print("{} record(s) inserted.".format(row_ct))
  1. Clique no botão Abrir terminal. Essa função do Cloud Run é acionada por uma mensagem do Pub/Sub. Para que funcione, crie primeiro o tópico do Pub/Sub com o comando a seguir.
gcloud pubsub topics create new-pet-topic
  1. Implante a função do Cloud Run com o seguinte comando. (A execução desse comando demora alguns minutos.)
gcloud functions deploy spanner_save_pets --runtime python310 --trigger-topic=new-pet-topic --region={{{project_0.default_region|place_holder_text}}} --quiet
  1. Quando o comando for concluído, no console, acesse o serviço Pub/Sub. Clique no tópico new-pet-topic para conferir os detalhes.
    Na página de detalhes, clique na guia Mensagens e depois no botão Publicar mensagem.
    Digite a mensagem abaixo e clique no botão Publicar. Observação: a mensagem está no formato JSON e precisa usar o esquema correto, como mostrado, para que a função funcione.
{"OwnerName": "Jean", "PetName": "Sally", "PetType": "Frog", "Breed": "Green"}
  1. Acione a função do Cloud Run spanner_gets_pets usando o comando curl executado antes. Verifique se a nova proprietária, Jean, e a rã, Sally, foram adicionadas.
curl -m 70 -X GET https://{{{project_0.default_region|place_holder_text}}}-${GOOGLE_CLOUD_PROJECT}.cloudfunctions.net/spanner_get_pets -H "Authorization: bearer $(gcloud auth print-identity-token)" -H "Content-Type: application/json"

Tarefa 4: iniciar o emulador Spanner

  1. No terminal do Cloud Shell, execute o comando a seguir para instalar e iniciar o emulador Spanner.
sudo apt-get install google-cloud-sdk-spanner-emulator gcloud emulators spanner start
  1. O emulador assume o terminal. Na barra de ferramentas do Cloud Shell, clique no ícone + para abrir uma nova guia do terminal. Execute os comandos a seguir para configurar o SDK Cloud para usar o emulador.
gcloud config configurations create emulator gcloud config set auth/disable_credentials true gcloud config set project $GOOGLE_CLOUD_PROJECT gcloud config set api_endpoint_overrides/spanner http://localhost:9020/
  1. Crie a instância e o banco de dados usando o gcloud, mas observe que esses comandos estão usando o emulador agora, não o Spanner na nuvem. Execute cada um deles separadamente, não como um todo.
cd ~/lab-files gcloud spanner instances create emulator-instance --config=emulator-config --description="EmulatorInstance" --nodes=1 gcloud spanner databases create pets-db --instance=emulator-instance --database-dialect=GOOGLE_STANDARD_SQL --ddl-file=./pets-db-schema.sql
  1. Para que o código da biblioteca de cliente Python use o emulador, a variável de ambiente SPANNER_EMULATOR_HOST precisa ser definida. Execute o código a seguir para fazer isso.
export SPANNER_EMULATOR_HOST=localhost:9010

Tarefa 5: criar uma API REST para o banco de dados Pets do Spanner

  1. Crie uma pasta para os arquivos do programa do Cloud Run e adicione os arquivos necessários.
mkdir ~/lab-files/cloud-run cd ~/lab-files/cloud-run touch Dockerfile main.py requirements.txt
  1. Clique no botão Abrir editor. No arquivo lab-files/cloud-run/requirements.txt que você acabou de criar, adicione o código a seguir.
Flask==3.0.3 Flask-RESTful==0.3.10 google-cloud-spanner==3.27.0 gunicorn==22.0.0
  1. Em main.py, adicione o seguinte. O código usa o Python Flask e a biblioteca Flask-RESTful para criar uma API REST para o banco de dados Pets.
    Observação: o uso das variáveis de ambiente no início do arquivo (linhas 11 a 20). Quando você implanta no Cloud Run, define essas variáveis para apontar para o banco de dados real do Spanner. Quando as variáveis não são definidas, o padrão é o emulador.
import os import uuid from flask import Flask, jsonify, request from flask_restful import Api, Resource from google.api_core import exceptions from google.cloud import spanner from werkzeug.exceptions import BadRequest, NotFound # --- Configuração --- # Use as configurações do emulador por padrão, mas substitua-as por variáveis de ambiente, se existirem. INSTANCE_ID = os.environ.get("INSTANCE_ID", "emulator-instance") DATABASE_ID = os.environ.get("DATABASE_ID", "pets-db") # --- Repositório do banco de dados --- classe SpannerRepository: """ A repository class to handle all database interactions with Google Cloud Spanner. This separates database logic from the API/view layer. """ def __init__(self, instance_id, database_id): spanner_client = spanner.Client() self.instance = spanner_client.instance(instance_id) self.database = self.instance.database(database_id) def list_all_pets(self): """Retrieves all pets with their owner information.""" query = """ SELECT o.OwnerID, o.OwnerName, p.PetID, p.PetName, p.PetType, p.Breed FROM Owners o JOIN Pets p ON o.OwnerID = p.OwnerID """ with self.database.snapshot() as snapshot: results = snapshot.execute_sql(query) # 1. Converta o iterador em uma lista de linhas. # Cada 'linha' nessa lista é uma lista de valores Python comum. rows = list(results) # 2. Se não houver linhas, os metadados podem estar incompletos. # Essa verificação previne o erro original 'NoneType'. if not rows: return [] # 3. Se houver linhas, o metadados estarão disponíveis. # Pegue os nomes das colunas nos metadados do resultado. # Nota: results.metadata é o atributo incorreto. keys = [field.name for field in results.metadata.row_type.fields] # 4. Combine as chaves com a lista de valores de cada linha para criar dicionários. return [dict(zip(keys, row)) for row in rows] def get_pet_by_id(self, pet_id): """Retrieves a single pet by its ID.""" query = """ SELECT o.OwnerID, o.OwnerName, p.PetID, p.PetName, p.PetType, p.Breed FROM Owners o JOIN Pets p ON o.OwnerID = p.OwnerID WHERE p.PetID = @pet_id """ params = {"pet_id": pet_id} param_types = {"pet_id": spanner.param_types.STRING} with self.database.snapshot() as snapshot: results = snapshot.execute_sql( query, params=params, param_types=param_types ) # results.one_or_none() retorna um objeto especial de linha (não uma lista) # que tem um método .keys(), por isso essa abordagem está correta e é mais simples. row = results.one_or_none() if not row: return None return dict(zip(row.keys(), row)) def create_pet_and_owner(self, data): """ Creates a new pet. If the owner doesn't exist, creates the owner as well. This entire operation is performed in a single transaction. """ def _tx_create_pet(transaction): pet_id = str(uuid.uuid4()) owner_name = data["OwnerName"] owner_result = transaction.execute_sql( "SELECT OwnerID FROM Owners WHERE OwnerName = @name", params={"name": owner_name}, param_types={"name": spanner.param_types.STRING}, ).one_or_none() if owner_result: owner_id = owner_result[0] else: owner_id = str(uuid.uuid4()) transaction.insert( "Owners", columns=("OwnerID", "OwnerName"), values=[(owner_id, owner_name)], ) pet_columns = ["PetID", "OwnerID", "PetName", "PetType", "Breed"] pet_values = [ pet_id, owner_id, data["PetName"], data["PetType"], data["Breed"], ] transaction.insert("Pets", columns=pet_columns, values=[pet_values]) new_pet_data = { "PetID": pet_id, "OwnerID": owner_id, "OwnerName": owner_name, "PetName": data["PetName"], "PetType": data["PetType"], "Breed": data["Breed"], } return new_pet_data return self.database.run_in_transaction(_tx_create_pet) def delete_pet_by_id(self, pet_id): """Deletes a single pet by its ID in a transaction.""" def _tx_delete_pet(transaction): return transaction.execute_update( "DELETE FROM Pets WHERE PetID = @pet_id", params={"pet_id": pet_id}, param_types={"pet_id": spanner.param_types.STRING}, ) return self.database.run_in_transaction(_tx_delete_pet) def delete_all_pets_and_owners(self): """Deletes all owners, which cascades to delete all pets.""" def _tx_delete_all(transaction): return transaction.execute_update("DELETE FROM Owners WHERE true") return self.database.run_in_transaction(_tx_delete_all) # --- Recursos da API --- db_repo = SpannerRepository(INSTANCE_ID, DATABASE_ID) class PetsList(Resource): def get(self): """Returns a list of all pets.""" pets = db_repo.list_all_pets() return jsonify(pets) def post(self): """Creates a new pet and possibly a new owner.""" try: data = request.get_json(force=True) required_fields = ["OwnerName", "PetName", "PetType", "Breed"] if not all(field in data for field in required_fields): raise BadRequest("Missing required fields in JSON payload.") except BadRequest as e: return {"message": str(e)}, 400 try: new_pet = db_repo.create_pet_and_owner(data) return new_pet, 201 except exceptions.GoogleAPICallError as e: return {"message": "Database transaction failed", "error": str(e)}, 500 def delete(self): """Deletes all owners and pets.""" deleted_count = db_repo.delete_all_pets_and_owners() return {"message": f"{deleted_count} owner record(s) deleted (pets cascaded)."}, 200 class Pet(Resource): def get(self, pet_id): """Returns a single pet by ID.""" pet = db_repo.get_pet_by_id(pet_id) if pet: return jsonify(pet) raise NotFound("Pet with the specified ID was not found.") def delete(self, pet_id): """Deletes a single pet by ID.""" try: deleted_count = db_repo.delete_pet_by_id(pet_id) if deleted_count > 0: return {"message": f"Pet with ID {pet_id} was deleted."}, 200 raise NotFound("Pet with the specified ID was not found.") except exceptions.NotFound: raise NotFound("Pet with the specified ID was not found.") def patch(self, pet_id): """This endpoint is not implemented.""" return {"message": "Update operation is not implemented."}, 501 # --- Inicialização do app Flask --- def create_app(): """Application factory to create and configure the Flask app.""" app = Flask(__name__) api = Api(app) # Roteamento de recursos da API api.add_resource(PetsList, "/pets") api.add_resource(Pet, "/pets/<string:pet_id>") # Tratamento centralizado de erros @app.errorhandler(NotFound) def handle_not_found(e): return jsonify({"message": str(e)}), 404 @app.errorhandler(BadRequest) def handle_bad_request(e): return jsonify({"message": str(e)}), 400 @app.errorhandler(Exception) def handle_generic_error(e): app.logger.error(f"An unhandled exception occurred: {e}", exc_info=True) return jsonify({"message": "An internal server error occurred."}), 500 return app app = create_app() if __name__ == "__main__": # Use debug=False em um ambiente de produção app.run(host="0.0.0.0", port=8080, debug=True)
  1. Clique no botão Abrir terminal e execute o código a seguir para instalar os pacotes necessários.
pip install -r requirements.txt
  1. Agora execute o código a seguir no terminal para iniciar o programa.
python main.py

  1. Na barra de ferramentas do Cloud Shell, clique no ícone + de novo para abrir uma terceira guia do terminal.

  2. É possível usar o curl para testar a API. Primeiro, adicione alguns registros usando os comandos POST HTTP.

curl -X POST --data '{"OwnerName": "Sue", "PetName": "Sparky", "PetType": "Cat", "Breed": "Alley"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Sue", "PetName": "Pickles", "PetType": "Dog", "Breed": "Shepherd"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Doug", "PetName": "Noir", "PetType": "Dog", "Breed": "Schnoodle"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Doug", "PetName": "Bree", "PetType": "Dog", "Breed": "Mutt"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Joey", "PetName": "Felix", "PetType": "Cat", "Breed": "Tabby"}' http://localhost:8080/pets
  1. Verifique se os registros foram adicionados usando um comando HTTP GET. Os registros devem ser retornados no formato JSON.
curl http://localhost:8080/pets Observação: caso você tenha perdido alguma etapa ou não esteja recebendo a saída desejada, tente seguir novamente as etapas na Tarefa 4 usando o Cloud Shell.
  1. Digite exit para fechar a terceira guia do terminal e pressione Ctrl + C para interromper o programa Python na segunda guia do terminal. Feche a segunda guia ao digitar exit.
    Volte para a primeira guia do terminal e interrompa o emulador pressionando Ctrl + C.
Observação: esses registros foram adicionados ao emulador. Em seguida, implante-os no Cloud Run e use a instância real do Spanner.

Tarefa 6: implantar um app no Cloud Run

  1. Para implantar no Cloud Run, você precisa de uma imagem Docker. Primeiro, mude os diretórios para a pasta cloud-run.
cd ~/lab-files/cloud-run
  1. Para criar a imagem Docker, adicione instruções ao arquivo Dockerfile. Clique no botão Abrir editor e abra o arquivo Dockerfile. Cole o código a seguir nele.
FROM python:3.9 WORKDIR /app COPY . . RUN pip install gunicorn RUN pip install -r requirements.txt ENV PORT=8080 CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 main:app
  1. Volte ao terminal e execute o código a seguir para criar a imagem Docker. (Verifique se você está na pasta ~/lab-files/cloud-run.)
gcloud builds submit --tag=gcr.io/$GOOGLE_CLOUD_PROJECT/spanner-pets-api:v1.0 .

  1. Verifique se o Cloud Run está ativado no seu projeto em Conheça e ative APIs.

  2. Agora, implante o aplicativo do Cloud Run usando o comando a seguir. Observe como as variáveis de ambiente são definidas no comando para que o código use a instância do Cloud Spanner, e não o emulador. A execução do comando leva alguns minutos.

gcloud run deploy spanner-pets-api --image gcr.io/$GOOGLE_CLOUD_PROJECT/spanner-pets-api:v1.0 --update-env-vars INSTANCE_ID=test-spanner-instance,DATABASE_ID=pets-db --region={{{project_0.default_region|place_holder_text}}}
  1. Quando o comando for concluído, anote o URL do serviço e copie para a área de transferência. Assim como no emulador, é possível usar comandos curl para testar a API. Primeiro, crie uma variável para armazenar o URL, como mostrado abaixo. Cole o URL completo, incluindo https://…, no lugar do marcador de posição completo: <YOUR_SERVICE_URL_HERE>.
pets_url=<YOUR_SERVICE_URL_HERE>
  1. Adicione alguns registros usando o curl.
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Sue", "PetName": "Sparky", "PetType": "Cat", "Breed": "Alley"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Sue", "PetName": "Pickles", "PetType": "Dog", "Breed": "Shepherd"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Doug", "PetName": "Noir", "PetType": "Dog", "Breed": "Schnoodle"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Doug", "PetName": "Bree", "PetType": "Dog", "Breed": "Mutt"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Joey", "PetName": "Felix", "PetType": "Cat", "Breed": "Tabby"}' $pets_url/pets

  1. Portanto, os registros foram adicionados. No console, acesse o serviço do Cloud Run e clique no serviço para conferir os detalhes e os registros. Cada solicitação que você fizer será registrada lá.

  2. Também é possível conferir se os registros foram adicionados.

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $pets_url/pets

  1. Acesse o Spanner e conheça a instância e o banco de dados.

  2. A API também implementa DELETE. Volte ao terminal e digite o comando a seguir para excluir todos os dados.

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X DELETE $pets_url/pets
  1. No console, exclua a instância do Spanner para não receber mais cobranças por ela.

Parabéns! Você criou aplicativos que usam bancos de dados do Spanner e os implantou no Cloud Run functions e no Cloud Run. Você também instalou, configurou e ativou o emulador Spanner para uso em ambientes de desenvolvimento.

Terminar o laboratório

Após terminar seu laboratório, clique em End Lab. O Qwiklabs removerá os recursos usados e limpará a conta para você.

Você poderá classificar sua experiência neste laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Submit.

O número de estrelas indica o seguinte:

  • 1 estrela = muito insatisfeito
  • 2 estrelas = insatisfeito
  • 3 estrelas = neutro
  • 4 estrelas = satisfeito
  • 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Support.

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de empresas e produtos podem ser marcas registradas das empresas a que estão associados.

Antes de começar

  1. Os laboratórios criam um projeto e recursos do Google Cloud por um período fixo
  2. Os laboratórios têm um limite de tempo e não têm o recurso de pausa. Se você encerrar o laboratório, vai precisar recomeçar do início.
  3. No canto superior esquerdo da tela, clique em Começar o laboratório

Usar a navegação anônima

  1. Copie o nome de usuário e a senha fornecidos para o laboratório
  2. Clique em Abrir console no modo anônimo

Fazer login no console

  1. Faça login usando suas credenciais do laboratório. Usar outras credenciais pode causar erros ou gerar cobranças.
  2. Aceite os termos e pule a página de recursos de recuperação
  3. Não clique em Terminar o laboratório a menos que você tenha concluído ou queira recomeçar, porque isso vai apagar seu trabalho e remover o projeto

Este conteúdo não está disponível no momento

Você vai receber uma notificação por e-mail quando ele estiver disponível

Ótimo!

Vamos entrar em contato por e-mail se ele ficar disponível

Um laboratório por vez

Confirme para encerrar todos os laboratórios atuais e iniciar este

Use a navegação anônima para executar o laboratório

Para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.