Como usar fluxos de trabalho para conectar serviços

Neste tutorial, você aprende a usar fluxos de trabalho para vincular uma série de serviços. Ao conectar dois serviços HTTP públicos usando o Cloud Functions (2ª geração), uma API REST externa e um serviço particular do Cloud Run, é possível criar um aplicativo flexível e sem servidor.

Objetivos

Neste tutorial, você vai usar a Google Cloud CLI para criar um único fluxo de trabalho, conectando um serviço por vez:

Implantar dois serviços do Cloud Functions: a primeira função gera um número aleatório e, em seguida, transmite esse número para a segunda função, que a multiplica.
Usando fluxos de trabalho, conecte as duas funções HTTP juntas. Execute o fluxo de trabalho e retorne um resultado que será transmitido para uma API externa.
Usando o Workflows, conecte uma API HTTP externa que retorne o log para um determinado número. Execute o fluxo de trabalho e retorne um resultado que é passado para um serviço do Cloud Run.
Implantar um serviço do Cloud Run que permita apenas o acesso autenticado. O serviço retorna math.floor para um determinado número.
Usando o Workflows, conecte o serviço do Cloud Run, execute todo o fluxo de trabalho e retorne um resultado final.

O diagrama a seguir mostra uma visão geral do processo e uma visualização do fluxo de trabalho final:

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.

Antes de começar

As restrições de segurança definidas pela sua organização podem impedir que você conclua as etapas a seguir. Para informações sobre solução de problemas, consulte Desenvolver aplicativos em um ambiente restrito do Google Cloud.

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Artifact Registry, Cloud Build, Cloud Functions, Cloud Run, Cloud Storage, and Workflows:

gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com cloudfunctions.googleapis.com run.googleapis.com storage.googleapis.com workflows.googleapis.com

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Artifact Registry, Cloud Build, Cloud Functions, Cloud Run, Cloud Storage, and Workflows:

gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com cloudfunctions.googleapis.com run.googleapis.com storage.googleapis.com workflows.googleapis.com

Atualize os componentes da Google Cloud CLI:
```
gcloud components update
```

Ao executar comandos no Cloud Shell, você já está autenticado na gcloud CLI. Caso contrário, faça login usando sua conta:
```
gcloud auth login
```

Defina o local padrão usado neste tutorial:

gcloud config set project PROJECT_ID
export REGION=REGION
gcloud config set functions/region ${REGION}
gcloud config set run/region ${REGION}
gcloud config set workflows/location ${REGION}

Substitua REGION pelo local do Workflows compatível de sua escolha.

Se você for o criador do projeto, receberá o papel de proprietário básico (roles/owner). Por padrão, esse papel do gerenciamento de identidade e acesso (IAM) inclui as permissões necessárias para acesso total à maioria dos recursos do Google Cloud, e você pode pular esta etapa.

Se você não é o criador do projeto, as permissões necessárias precisam ser concedidas ao principal apropriado. Por exemplo, um principal pode ser uma Conta do Google (para usuários finais) ou uma conta de serviço (para aplicativos e cargas de trabalho de computação). Para mais informações, consulte a página Papéis e permissões do destino do evento.
Permissões necessárias

Para conseguir as permissões necessárias para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:
- Editor do Cloud Build (roles/cloudbuild.builds.editor)
- Desenvolvedor do Cloud Functions (roles/cloudfunctions.developer)
- Administrador do Cloud Run (roles/run.admin)
- Criar contas de serviço (roles/iam.serviceAccountCreator)
- Administrador de projetos do IAM (roles/resourcemanager.projectIamAdmin)
- Usuário da conta de serviço (roles/iam.serviceAccountUser)
- Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
- Administrador de armazenamento (roles/storage.admin)
- Editor do Workflows (roles/workflows.editor)
Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Observação: os papéis básicos do IAM também podem conter permissões para concluir o tutorial. Não conceda papéis básicos em um ambiente de produção, mas é possível fazer isso em um ambiente de desenvolvimento ou teste.

Implantar o primeiro serviço do Cloud Functions

Depois de receber uma solicitação HTTP, essa função HTTP gera um número aleatório entre 1 e 100 e, em seguida, retorna o número no formato JSON.

Crie um diretório chamado randomgen e mude para ele:
```
mkdir ~/randomgen
cd ~/randomgen
```

Crie um arquivo de texto com o nome de arquivo main.py que contenha o seguinte código Python:

import functions_framework
import random
from flask import jsonify

@functions_framework.http
def randomgen(request):
    randomNum = random.randint(1, 100)
    output = {"random": randomNum}
    return jsonify(output)

Para aceitar uma dependência do Flask para processamento HTTP, crie um arquivo de texto para o gerenciador de pacotes pip. Nomeie o arquivo como requirements.txt e adicione o seguinte:
```
flask>=1.0.2
functions-framework==3.0.0
```

Crie uma conta de serviço para os fluxos de trabalho usarem:

export SERVICE_ACCOUNT=workflows-sa
gcloud iam service-accounts create ${SERVICE_ACCOUNT}

Para permitir que a conta de serviço chame serviços autenticados do Cloud Run, conceda o papel run.invoker à conta de serviço dos fluxos de trabalho:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/run.invoker"

Implante a função com um gatilho HTTP e permita acesso não autenticado:
```
gcloud functions deploy randomgen-function \
    --gen2 \
    --runtime python310 \
    --entry-point=randomgen \
    --trigger-http \
    --allow-unauthenticated
```
A função pode levar alguns minutos para ser implantada. Se preferir, use a interface do Cloud Functions no Console do Google Cloud para implantar a função.

Depois que a função randomgen for implantada, confirme a propriedade httpsTrigger.url:

gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)"

Salve o URL. É necessário adicioná-lo ao arquivo de origem do fluxo de trabalho em exercícios posteriores.

Teste a função com o seguinte comando curl:

curl $(gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)")

Um número é gerado e retornado aleatoriamente.

Implantar o segundo serviço do Cloud Functions

Depois de receber uma solicitação HTTP, essa função HTTP extrai o input do corpo JSON, multiplica-o por dois e retorna o resultado no formato JSON.

Volte ao diretório principal.
```
cd ~
```
Crie um diretório chamado multiply e mude para ele:
```
mkdir ~/multiply
cd ~/multiply
```

Crie um arquivo de texto com o nome de arquivo main.py que contenha o seguinte código Python:

import functions_framework
from flask import jsonify

@functions_framework.http
def multiply(request):
    request_json = request.get_json()
    output = {"multiplied": 2 * request_json['input']}
    return jsonify(output)

Para aceitar uma dependência do Flask para processamento HTTP, crie um arquivo de texto para o gerenciador de pacotes pip. Nomeie o arquivo como requirements.txt e adicione o seguinte:
```
flask>=1.0.2
functions-framework==3.0.0
```
Implante a função com um gatilho HTTP e permita acesso não autenticado:
```
gcloud functions deploy multiply-function \
    --gen2 \
    --runtime python310 \
    --entry-point=multiply \
    --trigger-http \
    --allow-unauthenticated
```
A implantação da função pode levar alguns minutos.Também é possível usar a interface do Cloud Functions no Console do Google Cloud para implantar a função.

Depois que a função multiply for implantada, confirme a propriedade httpsTrigger.url:

gcloud functions describe multiply-function \
    --gen2\
    --format="value(serviceConfig.uri)"

Salve o URL. É necessário adicioná-lo ao arquivo de origem do fluxo de trabalho em exercícios posteriores.

Teste a função com o seguinte comando curl:

curl -X POST MULTIPLY_FUNCTION_URL \
    -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"input": 5}'

O número 10 deve ser retornado.

Conectar os dois serviços do Cloud Functions em um fluxo de trabalho

Um fluxo de trabalho é composto por uma série de etapas descritas usando a sintaxe dos fluxos de trabalho, que pode ser escrita em formato YAML ou JSON. Essa é a definição do fluxo de trabalho. Para uma explicação detalhada, consulte a página Referência de sintaxe.

Volte ao diretório principal.
```
cd ~
```
Crie um arquivo de texto com o nome workflow.yaml que contenha o conteúdo a seguir:
```
- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- return_result:
    return: ${multiply_result}
```
- Substitua RANDOMGEN_FUNCTION_URL pelo URL da função randomgen.
- Substitua MULTIPLY_FUNCTION_URL pelo URL da função multiply.
Esse arquivo de origem vincula as duas funções HTTP e retorna um resultado final.

Observação: para fazer uma solicitação a uma função do Cloud Functions que aceita apenas chamadas autenticadas, use o OIDC para autenticação. Para mais informações, consulte Fazer solicitações autenticadas de um fluxo de trabalho.
Depois de criar o fluxo de trabalho, é possível implantá-lo, o que o prepara para a execução.
```
gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml
```
Substitua WORKFLOW_NAME por um nome para o fluxo de trabalho.
Execute o fluxo de trabalho:
```
gcloud workflows run WORKFLOW_NAME
```
Uma execução é uma única execução da lógica contida na definição de um fluxo de trabalho. Todas as execuções de fluxo de trabalho são independentes, e o rápido escalonamento do Workflows permite um grande número de execuções simultâneas.

Depois que o fluxo de trabalho for executado, o resultado será semelhante a este:
```
result: '{"body":{"multiplied":120},"code":200,"headers":{"Alt-Svc":"h3-29=\":443\";
...
startTime: '2021-05-05T14:17:39.135251700Z'
state: SUCCEEDED
...
```

Conectar um serviço REST público no fluxo de trabalho

Atualizar seu fluxo de trabalho atual e conectar uma API REST pública (math.js) que pode avaliar expressões matemáticas. Por exemplo, curl https://api.mathjs.org/v4/?'expr=log(56)'.

Como você implantou seu fluxo de trabalho, também pode editá-lo na página "Fluxos de trabalho" no console do Google Cloud.

Edite o arquivo de origem do fluxo de trabalho e substitua-o pelo conteúdo a seguir:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- log_function:
    call: http.get
    args:
        url: https://api.mathjs.org/v4/
        query:
            expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
    result: log_result
- return_result:
    return: ${log_result}

Substitua RANDOMGEN_FUNCTION_URL pelo URL da função randomgen.
Substitua MULTIPLY_FUNCTION_URL pelo URL da função multiply.

Isso vincula o serviço REST externo aos serviços do Cloud Functions e retorna um resultado final.

Implante o fluxo de trabalho modificado:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml

Implantar um serviço do Cloud Run

Implantar um serviço do Cloud Run que, depois de receber uma solicitação HTTP, extrai input do corpo JSON, calcula o math.floor e retorna o resultado.

Crie um diretório chamado floor e mude para ele:
```
mkdir ~/floor
cd ~/floor
```

Crie um arquivo de texto com o nome de arquivo app.py que contenha o seguinte código Python:

import json
import logging
import os
import math

from flask import Flask, request

app = Flask(__name__)

@app.route('/', methods=['POST'])
def handle_post():
    content = json.loads(request.data)
    input = float(content['input'])
    return f"{math.floor(input)}", 200

if __name__ != '__main__':
    # Redirect Flask logs to Gunicorn logs
    gunicorn_logger = logging.getLogger('gunicorn.error')
    app.logger.handlers = gunicorn_logger.handlers
    app.logger.setLevel(gunicorn_logger.level)
    app.logger.info('Service started...')
else:
    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

No mesmo diretório, crie um Dockerfile com o seguinte conteúdo:

# Use an official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.7-slim

# Install production dependencies.
RUN pip install Flask gunicorn

# Copy local code to the container image.
WORKDIR /app
COPY . .

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind 0.0.0.0:8080 --workers 1 --threads 8 app:app

Crie um repositório padrão do Artifact Registry para armazenar a imagem do contêiner do Docker:
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=${REGION}
```
Substitua REPOSITORY por um nome exclusivo para o repositório.

Crie a imagem do contêiner:

export SERVICE_NAME=floor
gcloud builds submit --tag ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}

Implante a imagem do contêiner no Cloud Run, garantindo que ele aceite apenas chamadas autenticadas:

gcloud run deploy ${SERVICE_NAME} \
    --image ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}:latest \
    --no-allow-unauthenticated

Quando você vir o URL do serviço, a implantação estará concluída. Você precisará especificar esse URL ao atualizar a definição do fluxo de trabalho.

Conectar o serviço Cloud Run no fluxo de trabalho

Atualize o fluxo de trabalho atual e especifique o URL do serviço do Cloud Run.

Edite o arquivo de origem do fluxo de trabalho e substitua-o pelo conteúdo a seguir:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- log_function:
    call: http.get
    args:
        url: https://api.mathjs.org/v4/
        query:
            expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
    result: log_result
- floor_function:
    call: http.post
    args:
        url: CLOUD_RUN_SERVICE_URL
        auth:
            type: OIDC
        body:
            input: ${log_result.body}
    result: floor_result
- create_output_map:
    assign:
      - outputMap:
          randomResult: ${randomgen_result}
          multiplyResult: ${multiply_result}
          logResult: ${log_result}
          floorResult: ${floor_result}
- return_output:
    return: ${outputMap}

Substitua RANDOMGEN_FUNCTION_URL pelo URL da função randomgen.
Substitua MULTIPLY_FUNCTION_URL pelo URL da função multiply.
Substitua CLOUD_RUN_SERVICE_URL pelo URL do serviço do Cloud Run.

Isso conecta o serviço Cloud Run ao fluxo de trabalho. A chave auth garante que um token de autenticação seja transmitido na chamada ao serviço do Cloud Run. Para mais informações, consulte Fazer solicitações autenticadas de um fluxo de trabalho.

Implante o fluxo de trabalho modificado:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml

Executar o fluxo de trabalho final:

gcloud workflows run WORKFLOW_NAME

A saída será semelhante a esta:

result: '{"Floor":{"body":"4","code":200
  ...
  "Log":{"body":"4.02535169073515","code":200
  ...
  "Multiply":{"body":{"multiplied":56},"code":200
  ...
  "Random":{"body":{"random":28},"code":200
  ...
startTime: '2023-11-13T21:22:56.782669001Z'
state: SUCCEEDED

Parabéns! Você implantou e executou um fluxo de trabalho que conecta uma série de serviços.

Para criar fluxos de trabalho mais complexos usando expressões, saltos condicionais, codificação/decodificação Base64, subfluxos de trabalho e muito mais, consulte a Referência de sintaxe dos fluxos de trabalho e a Visão geral da biblioteca padrão.

Limpar

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluir o projeto que você criou para o tutorial.

Para excluir o projeto:

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.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

delete-tutorial-resources

Exclua o serviço do Cloud Run que você implantou neste tutorial.
Exclua o fluxo de trabalho criado neste tutorial.
Exclua a imagem do contêiner do Artifact Registry.
Exclua o repositório do Artifact Registry.

Remova as configurações padrão da CLI Google Cloud adicionadas durante a configuração do tutorial:

gcloud config unset functions/region
gcloud config unset run/region
gcloud config unset workflows/location
gcloud config unset project