Visão geral

Esta é a versão mais recente do Cloud Run functions do Google, o produto de Funções como serviço do Google Cloud. Ela oferece um conjunto de recursos avançados com tecnologia do Cloud Run e do Eventarc, que tem um controle mais avançado do desempenho e da escalonabilidade, além de mais domínio sobre o tempo de execução e acionadores de mais de 90 fontes de evento.

Neste laboratório, você vai criar funções do Cloud Run que respondem a solicitações HTTP e funções acionadas por eventos do Cloud Storage, além de implantar várias revisões de uma função do Cloud Run e testar novas configurações.

Novidades

Esta nova versão do Cloud Run functions oferece uma experiência de FaaS otimizada com tecnologia do Cloud Run, do Cloud Build, do Artifact Registry e do Eventarc.

• Processamento de solicitações mais longo: execute suas funções do Cloud Run por mais tempo do que o padrão de 5 minutos, facilitando a execução de cargas de trabalho de solicitações mais longas, como o processamento de grandes fluxos de dados do Cloud Storage ou do BigQuery. Para funções HTTP, o tempo é de até 60 minutos. Para funções orientadas por eventos, o tempo é de até 10 minutos.
• Instâncias maiores: aproveite até 16 GB de RAM e 4 vCPUs no Cloud Run functions, permitindo cargas de trabalho maiores na memória, com uso intensivo de computação e mais processamento paralelo.
• Simultaneidade: processe até 1.000 solicitações ao mesmo tempo com uma só instância de função, reduzindo o número de inicializações a frio e melhorando a latência na hora de escalonar.
• Instâncias mínimas: instâncias pré aquecidas para reduzir as inicializações a frio e garantir que o tempo de inicialização do aplicativo não afete o desempenho dele.
• Divisão de tráfego: suporte a várias versões das funções, divisão de tráfego em diferentes versões e reversão para versões anteriores de uma função.

Objetivos

Neste laboratório, você vai:

• Escrever uma função que responda a solicitações HTTP e implantar usando o console do Google Cloud.
• Escrever uma função que responda a eventos do Cloud Storage e implantar no ambiente local do Cloud Shell.
• Criar testes de unidade para a função e fazê-los localmente.
• Implantar várias revisões de uma função do Cloud Run usando o console do Google Cloud.
• Testar a revisão mais recente da função e verificar se ela funciona conforme o esperado.

Configuração

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud.

O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

• Para listar o nome da conta ativa, use este comando:

Saída:

Exemplo de saída:

• Para listar o ID do projeto, use este comando:

Saída:

Exemplo de saída:

Tarefa 1: ativar APIs

Antes de criar funções do Cloud Run, você tem que ativar as APIs relevantes.

1. Faça login no console do Google Cloud com as credenciais do laboratório e abra a janela do terminal do Cloud Shell.

2. Execute os comandos a seguir no Cloud Shell para definir as variáveis de ambiente do ID do projeto e da região:

   PROJECT_ID=$(gcloud config get-value project) REGION={{{project_0.default_region|set at lab start}}}

3. Execute o comando abaixo para ativar todas as APIs de serviço necessárias.

   gcloud services enable \ artifactregistry.googleapis.com \ cloudfunctions.googleapis.com \ cloudbuild.googleapis.com \ eventarc.googleapis.com \ run.googleapis.com \ logging.googleapis.com \ storage.googleapis.com \ pubsub.googleapis.com

4. Se solicitado, clique em Autorizar.

Tarefa 2: criar uma função HTTP

Primeiro crie uma função do Node.js autenticada que responda a solicitações HTTP para converter um valor de temperatura de Fahrenheit para Celsius e responder com o valor de temperatura convertido.

Crie a função

1. Para acessar o Cloud Run functions, no Menu de navegação (), clique em Cloud Run functions.

   Observação: se o Cloud Run functions não aparecer no menu de navegação, clique em Ver todos os produtos. Role a tela até a seção sobre Sem servidor, clique no pino ao lado de Cloud Run functions e, em seguida, em Cloud Run functions.

   Você será redirecionado para o Cloud Run no console.

2. Clique em Escrever uma função.

3. Em Nome do serviço, digite temperature-converter.

4. Em Região, selecione a região .

5. Em Autenticação, selecione Exigir autenticação.

6. Role a tela para baixo e abra Contêineres, volumes, rede, segurança.

7. Em Escalonamento de revisão, insira 1 em Número máximo de instâncias.

8. Não mexa nas outras configurações e clique em Criar.

9. A função será implementada em Node.js. Na guia Origem, clique no ícone de edição ao lado da Imagem de base, selecione a versão mais recente do ambiente de execução Node.js e clique em Salvar.

10. Em Ponto de entrada da função, digite convertTemp.

11. No Editor Inline, substitua qualquer exemplo de código atual por este código no arquivo index.js:

    const functions = require('@google-cloud/functions-framework'); functions.http('convertTemp', (req, res) => { var dirn = req.query.convert; var ctemp = (req.query.temp - 32) * 5/9; var target_unit = 'Celsius'; if (req.query.temp === undefined) { res.status(400); res.send('Temperature value not supplied in request.'); } if (dirn === undefined) dirn = process.env.TEMP_CONVERT_TO; if (dirn === 'ctof') { ctemp = (req.query.temp * 9/5) + 32; target_unit = 'Fahrenheit'; } res.send(`Temperature in ${target_unit} is: ${ctemp.toFixed(2)}.`); });

    Esta é uma função HTTP simples em Node.js que converte um valor de temperatura em Fahrenheit ou Celsius transmitido na solicitação e responde com o valor convertido.

    Functions Framework é uma biblioteca e um framework FaaS (função como serviço) de código aberto que permite criar funções compactas para execução em ambientes diferentes, incluindo funções do Cloud Run, máquinas de desenvolvimento locais e o Cloud Run.

    Para mais informações, consulte a documentação do Functions Framework.

Implante e teste a função

1. Para implantar a função, clique em Salvar e reimplantar. Espere o Cloud Build e o serviço do Cloud Run serem criados.

   Quando a função é implantada, uma marca de seleção verde aparece ao lado do nome da função na página Serviços do Cloud Run.

   

2. No Cloud Shell, recupere o URI HTTP da função e armazene-o em uma variável de ambiente:

   FUNCTION_URI=$(gcloud run services describe temperature-converter --region $REGION --format 'value(status.url)'); echo $FUNCTION_URI

3. No Cloud Shell, teste a função com este comando:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?temp=70"

   Esta resposta será exibida:

   A temperatura em Celsius é: 21,11.

4. Execute o comando outra vez transmitindo o valor da temperatura em Celsius e a unidade de conversão:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?temp=21.11&convert=ctof"

   Esta resposta será exibida:

   A temperatura em Fahrenheit é: 70,00.

Clique em Verificar meu progresso para conferir o objetivo. Criar uma função HTTP

Tarefa 3: criar uma função do Cloud Storage

Nesta tarefa, você vai criar uma função orientada por eventos em Node.js para responder a eventos de um bucket do Cloud Storage.

Configuração

Para usar gatilhos do Cloud Storage com funções do Cloud Storage, o agente de serviço do Cloud Storage precisa ter o papel do IAM Publicador do Pub/Sub (roles/pubsub.editor) no projeto.

As funções do Cloud Storage são baseadas em notificações do Pub/Sub do Cloud Storage e podem ser usadas com os tipos de evento finalize, delete, archive e metadata update.

1. Defina uma variável de ambiente para a conta de serviço do agente do Cloud Storage:

   SERVICE_ACCOUNT=$(gcloud storage service-agent)

2. Conceda o papel de Publicador do Pub/Sub ao agente de serviço do Cloud Storage no projeto. Um agente de serviço é uma conta de serviço gerenciada pelo Google que permite que o serviço acesse seus recursos.

   gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:$SERVICE_ACCOUNT --role roles/pubsub.publisher

3. Para acionar a função em uma tarefa posterior, você vai fazer upload de um arquivo no Cloud Storage. Copie este arquivo contendo amostras de dados de temperatura para o ambiente do Cloud Shell:

   gcloud storage cp gs://cloud-training/CBL491/data/average-temps.csv .

Crie a função

1. Nesta subtarefa, você vai desenvolver uma função localmente no Cloud Shell. Crie um diretório e o acesse:

   mkdir ~/temp-data-checker && cd $_

2. Crie os arquivos index.js e package.json para a função Node.js:

   touch index.js && touch package.json

3. Na barra de ferramentas do Cloud Shell, clique em Abrir editor.

   É possível mudar do Cloud Shell para o editor de código (e vice-versa) clicando em Abrir editor e Abrir terminal ou deixar o editor aberto em uma guia separada clicando em Abrir em uma nova janela.

4. No Explorador, abra a pasta temp-data-checker.

5. Adicione o código a seguir ao arquivo temp-data-checker/index.js:

   const functions = require('@google-cloud/functions-framework'); // Registre uma chamada de retorno do CloudEvent com o framework do Functions que será // acionada por eventos do Cloud Storage. functions.cloudEvent('checkTempData', cloudEvent => { console.log(`Event ID: ${cloudEvent.id}`); console.log(`Event Type: ${cloudEvent.type}`); const file = cloudEvent.data; console.log(`Bucket: ${file.bucket}`); console.log(`File: ${file.name}`); console.log(`Created: ${file.timeCreated}`); }); A função usa instruções `console.log` para mensagens de registro no stdout. O Cloud Run functions inclui por padrão a geração simples de registros do ambiente de execução. As mensagens de registro são selecionadas e analisadas pelo Cloud Run functions e enviadas para o Cloud Logging, onde podem ser visualizadas no console do Cloud.

6. Para especificar dependências e outras informações do pacote para a função do Node.js, adicione o conteúdo a serguir ao arquivo temp-data-checker/package.json:

   { "name": "temperature-data-checker", "version": "0.0.1", "main": "index.js", "dependencies": { "@google-cloud/functions-framework": "^2.1.0" } }

Implante a função

1. Volte para a janela do terminal do Cloud Shell e defina uma variável de ambiente para o nome do bucket:

   BUCKET="gs://gcf-temperature-data-$PROJECT_ID"

2. Crie um bucket do Cloud Storage para armazenar o arquivo de dados de temperatura:

   gcloud storage buckets create -l $REGION $BUCKET

3. Para implantar a função, execute este comando no Cloud Shell:

   gcloud functions deploy temperature-data-checker \ --gen2 \ --runtime nodejs20 \ --entry-point checkTempData \ --source . \ --region $REGION \ --trigger-bucket $BUCKET \ --trigger-location $REGION \ --max-instances 1

   Com o trigger-bucket especificado, qualquer mudança feita nos arquivos desse bucket vai acionar a execução da função.

   Observação: se um erro de permissões for exibido, espere alguns minutos e tente implantar outra vez. A ativação das APIS leva um tempo.

4. Verifique se a função foi implantada com sucesso.

   

Teste a função

1. Para testar a função, faça upload do arquivo de dados de temperatura para o bucket do Cloud Storage:

   gcloud storage cp ~/average-temps.csv $BUCKET/average-temps.csv

2. Execute o comando a seguir. As informações do CloudEvent recebido serão exibidas nos registros:

   gcloud functions logs read temperature-data-checker \ --region $REGION --gen2 --limit=100 --format "value(log)" Observação: a geração dos registros pode levar um minuto.

   A resposta será parecida com esta:

   Created: 2024-08-28T13:18:34.980Z File: average-temps.csv Bucket: gcf-temperature-data-cf-project Event Type: google.cloud.storage.object.v1.finalized Event ID: 5834307012388233 A função do Cloud Storage criada neste laboratório extrai metadados sobre o bucket e o recurso que foi criado. Para extrair e processar os dados com serviços downstream, use as bibliotecas de cliente do Cloud Storage para o ambiente de execução da sua linguagem.

Clique em Verificar meu progresso para conferir o objetivo. Criar uma função do Cloud Storage

Tarefa 4: desenvolvimento e teste locais

O Cloud Run functions é compatível com vários métodos de execução de funções fora do próprio ambiente. Isso é útil para questões de desenvolvimento iterativo e de conformidade com a localização de dados, para testes de pré-implantação em ambientes locais e para implantações multicloud.

Nesta tarefa, você vai modificar uma função HTTP, desenvolver testes de unidade e de integração e testar a função localmente antes de implantá-la no Cloud Run functions.

Faça o download do código-fonte da função

1. Para acessar as funções do Cloud Run, no Menu de navegação (), clique em Cloud Run.

2. Para ver os detalhes da função temperature-converter, selecione o nome dela.

3. Para visualizar o código-fonte da função, clique na guia FONTE.

4. Clique em Baixar aqruivo e salve o ZIP em uma pasta do seu computador com o nome function-source.zip.

5. Na barra de ferramentas do Cloud Shell, clique no menu Mais () e depois em Fazer upload.

6. Na caixa de diálogo Fazer upload, clique em Escolher arquivos.

7. Selecione o arquivo ZIP que você baixou na pasta, clique em Abrir e depois em Fazer upload na caixa de diálogo.

8. Depois de fazer o upload do arquivo, execute este comando no Cloud Shell:

   mkdir ~/temp-data-converter && cd $_

9. Extraia o conteúdo do arquivo ZIP:

   unzip ../function-source.zip

Adicione testes de unidade ao código da função

Primeiro, vamos adicionar alguns testes de unidade à função temperature-convert.

1. Crie um diretório que vai conter todos os testes de função e o arquivo de origem do teste de unidade:

   mkdir tests && touch tests/unit.http.test.js

2. Na barra de ferramentas do Cloud Shell, clique em Abrir editor.

3. No editor, adicione o código abaixo ao arquivo temp-data-converter/tests/unit.http.test.js. O código de teste cria uma simulação que une solicitações e respostas HTTP e usa stubs do Sinon para interpretar as respostas recebidas da função.

   const {getFunction} = require('@google-cloud/functions-framework/testing'); describe('functions_convert_temperature_http', () => { // Sinon é um framework de testes usado para criar simulações para aplicativos Node.js escritas em Express. // Express é um framework de aplicação web Node.js usado para implementar funções HTTP. const sinon = require('sinon'); const assert = require('assert'); require('../'); const getMocks = () => { const req = {body: {}, query: {}}; return { req: req, res: { send: sinon.stub().returnsThis(), status: sinon.stub().returnsThis() }, }; }; let envOrig; before(() => { envOrig = JSON.stringify(process.env); }); after(() => { process.env = JSON.parse(envOrig); }); it('convertTemp: should convert a Fahrenheit temp value by default', () => { const mocks = getMocks(); mocks.req.query = {temp: 70}; const convertTemp = getFunction('convertTemp'); convertTemp(mocks.req, mocks.res); assert.strictEqual(mocks.res.send.calledOnceWith('Temperature in Celsius is: 21.11.'), true); }); it('convertTemp: should convert a Celsius temp value', () => { const mocks = getMocks(); mocks.req.query = {temp: 21.11, convert: 'ctof'}; const convertTemp = getFunction('convertTemp'); convertTemp(mocks.req, mocks.res); assert.strictEqual(mocks.res.send.calledOnceWith('Temperature in Fahrenheit is: 70.00.'), true); }); it('convertTemp: should convert a Celsius temp value by default', () => { process.env.TEMP_CONVERT_TO = 'ctof'; const mocks = getMocks(); mocks.req.query = {temp: 21.11}; const convertTemp = getFunction('convertTemp'); convertTemp(mocks.req, mocks.res); assert.strictEqual(mocks.res.send.calledOnceWith('Temperature in Fahrenheit is: 70.00.'), true); }); it('convertTemp: should return an error message', () => { const mocks = getMocks(); const convertTemp = getFunction('convertTemp'); convertTemp(mocks.req, mocks.res); assert.strictEqual(mocks.res.status.calledOnce, true); assert.strictEqual(mocks.res.status.firstCall.args[0], 400); }); }); Observação: temos quatro testes de unidade, sendo que três são positivos e esperam um determinado valor de temperatura na resposta da função.

   O quarto teste, que é negativo, espera que a função retorne um código de status de resposta 400 (Solicitação inválida), porque não há um valor de temperatura transmitido no objeto da solicitação.

4. No arquivo temp-data-converter/package.json, atualize as dependências da função Node.js para incluir as seções scripts e devDependencies:

   { "name": "temperature-converter", "version": "0.0.1", "main": "index.js", "scripts": { "unit-test": "mocha tests/unit*test.js --timeout=6000 --exit", "test": "npm -- run unit-test" }, "devDependencies": { "mocha": "^9.0.0", "sinon": "^14.0.0" }, "dependencies": { "@google-cloud/functions-framework": "^2.1.0" } }

Execute os testes de unidade

1. Na janela do terminal do Cloud Shell, execute este comando para instalar as dependências da função:

   npm install O comando executa o gerenciador de pacotes do Node, que faz o download de todas as dependências definidas no arquivo package.json.

2. Execute o teste de unidade:

   npm test

3. Na resposta ao comando, verifique se todos os testes foram aprovados.

   > temperature-converter@0.0.1 test > npm -- run unit-test > temperature-converter@0.0.1 unit-test > mocha tests/unit*test.js --timeout=6000 --exit functions_convert_temperature_http ✔ convertTemp: should convert a Fahrenheit temp value by default ✔ convertTemp: should convert a Celsius temp value ✔ convertTemp: should convert a Celsius temp value by default ✔ convertTemp: should return an error message 4 passing (10ms) O Mocha é um framework de teste em JavaScript executado no Node.js e permite testes assíncronos de um jeito simples e flexível. Também é recomendável que você implemente testes de unidade, de integração e do sistema para funções do Cloud Run orientadas por eventos e HTTP. Para saber mais sobre a implementação de testes pré-implantação, consulte os links na seção Saiba mais no final deste laboratório.

Tarefa 5: criar revisões de função

O Cloud Run functions permite várias revisões de uma função, para que você divida o tráfego entre revisões diferentes ou reverta a função para uma revisão anterior.

Toda vez que você implanta ou reimplanta uma função, uma revisão do serviço do Cloud Run é criada automaticamente. As revisões são imutáveis e não podem ser modificadas depois de criadas. Para fazer mudanças em uma função, ela precisa ser reimplantada.

Nesta tarefa, você vai implantar a função HTTP criada na tarefa anterior com uma variável de ambiente e usar o console do Google Cloud para gerenciar o tráfego entre duas revisões da função.

Reimplante a função

1. No console do Google Cloud, navegue até a página Detalhes da função da função temperature-converter.

2. Clique em Editar e implantar nova revisão.

3. Na guia Contêiner, selecione a guia Variáveis e Secrets.

4. Para acrescentar uma variável de ambiente, clique em Adicionar variável na seção Variáveis de ambiente.

5. Em Nome 1, digite TEMP_CONVERT_TO

6. Para dar um valor à variável de ambiente, digite ctof em Valor 1

7. Clique em Implantar.

8. Espere o processo de implantação chegar ao fim. Depois da conclusão, duas revisões da função serão exibidas.

   Por padrão, a revisão implantada mais recente recebe 100% do tráfego da função. Essa revisão é implantada com uma variável de ambiente que instrui a função a converter, por padrão, todos os valores de temperatura de Celsius para Fahrenheit.

Teste a revisão mais recente da função

1. Para testar a função, execute no Cloud Shell o comando curl com o valor do parâmetro de consulta temp em Celsius:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?temp=21.11"

   Esta resposta da função vai aparecer:

   A temperatura em Fahrenheit é: 70,00.

Clique em Verificar meu progresso para conferir o objetivo. Criar revisões de função

Parabéns!

Neste laboratório, você implantou funções do Cloud Run que responderam a solicitações HTTP e a eventos do Cloud Storage. Você implementou testes de pré-implantação com testes de unidade para uma função HTTP e os executou para verificar cenários positivos e negativos ao chamar a função. Além disso, você implantou várias revisões de uma função e testou a revisão mais recente para verificar o comportamento da função.

Próximas etapas / Saiba mais

Para mais informações sobre funções do Cloud Run, consulte a documentação:

• Cloud Run functions
• Como testar funções do Cloud Run

Copyright 2025 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.