Pausar e retomar um fluxo de trabalho usando callbacks e o app Planilhas Google


As Planilhas Google são uma solução de planilhas baseada na nuvem que oferece suporte à colaboração em tempo real e ferramentas para visualizar, processar e comunicar dados.

Neste tutorial, mostramos como criar e implantar um fluxo de trabalho que cria um endpoint de callback (ou webhook), salva o URL de callback no Google Sheets, pausa a execução e aguarda a aprovação humana na planilha do Sheets para reiniciar o fluxo de trabalho. Saiba mais sobre como usar callbacks.

Objetivos

Com este tutorial, você vai:

  1. Crie uma pasta no Google Drive. Essa pasta é usada para armazenar sua planilha e permite que o fluxo de trabalho grave nela.
  2. Crie uma planilha Google para capturar uma aprovação e iniciar um callback para um fluxo de trabalho.
  3. Use o Google Apps Script, uma plataforma JavaScript baseada na nuvem que permite criar, ler e editar produtos do Google Workspace de forma programática, para acionar a retomada de um fluxo de trabalho pausado sempre que uma solicitação for aprovada com uma atualização na planilha.
  4. Crie e implante um fluxo de trabalho que chame o conector da API Google Sheets para anexar dados à planilha. O fluxo de trabalho é executado, pausado e retomado quando um callback é aprovado na planilha. Saiba mais sobre os conectores do Workflows.
  5. Teste todo o processo e confirme se o fluxo de trabalho prossegue conforme o esperado.

Custos

Neste documento, você vai 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.

O tutorial também usa o Google Workspace. Os serviços de nível empresarial que não estão incluídos nos apps gratuitos do Google para consumidores são cobrados.

Antes de começar

É possível executar alguns dos comandos a seguir no console Google Cloud ou usando a Google Cloud CLI no terminal ou no Cloud Shell.

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 de Google Cloud .

Console

  1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um Google Cloud projeto.

    Acessar o seletor de projetos

  2. Verifique se o faturamento foi ativado para o projeto Google Cloud . Saiba como verificar se o faturamento está ativado em um projeto.

  3. Ative as APIs Compute Engine, Sheets e Workflows.

    Ative as APIs

  4. Anote a conta de serviço padrão do Compute Engine, porque você vai associá-la ao fluxo de trabalho neste tutorial para fins de teste. Os novos projetos que ativaram a API Compute Engine têm essa conta de serviço criada com o papel básico de editor do IAM e com o seguinte formato de e-mail:

    PROJECT_NUMBER-compute@developer.gserviceaccount.com

    Você encontra o número do projeto na página Boas-vindas do Google Cloud console.

    Para ambientes de produção, é altamente recomendável criar uma nova conta de serviço, conceder a ela um ou mais papéis do IAM que contenham as permissões mínimas necessárias, bem como seguir o princípio de privilégio mínimo.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verifique se o faturamento foi ativado para o projeto Google Cloud . Saiba como verificar se o faturamento está ativado em um projeto.

  3. Ative as APIs Compute Engine, Sheets e Workflows.

    gcloud services enable \
        compute.googleapis.com \
        sheets.googleapis.com \
        workflows.googleapis.com
  4. Anote a conta de serviço padrão do Compute Engine, porque você vai associá-la ao fluxo de trabalho neste tutorial para fins de teste. Os novos projetos que ativaram a API Compute Engine têm essa conta de serviço criada com o papel básico de editor do IAM e com o seguinte formato de e-mail:

    PROJECT_NUMBER-compute@developer.gserviceaccount.com

    Para recuperar o número do projeto:

    gcloud projects describe PROJECT_ID

    Para ambientes de produção, é altamente recomendável criar uma nova conta de serviço, conceder a ela um ou mais papéis do IAM que contenham as permissões mínimas necessárias, bem como seguir o princípio de privilégio mínimo.

Criar uma pasta no Google Drive

Crie uma pasta no Google Drive. Essa pasta é usada para armazenar sua planilha. Ao configurar uma permissão para a pasta compartilhada, seu fluxo de trabalho pode gravar na planilha.

  1. Acesse drive.google.com.
  2. Clique em Novo > Nova pasta.
  3. Digite um nome para a pasta.
  4. Clique em Criar.
  5. Clique com o botão direito do mouse na nova pasta e selecione Compartilhar.
  6. Adicione o endereço de e-mail da conta de serviço padrão do Compute Engine.

    Isso dá à conta de serviço acesso à pasta. Quando você associa a conta de serviço ao fluxo de trabalho, ele tem acesso de edição a qualquer arquivo na pasta. Saiba mais sobre como compartilhar arquivos, pastas e drives.

  7. Selecione o papel Editor.

  8. Desmarque a caixa de seleção Notificar pessoas.

  9. Clique em Compartilhar.

Criar uma planilha usando as Planilhas Google

Quando você cria uma planilha no Planilhas Google, ela é salva no Google Drive. Por padrão, a planilha é salva na pasta raiz do Drive. Não há opção para criar uma planilha diretamente em uma pasta especificada usando a API Google Sheets. No entanto, há alternativas, incluindo mover a planilha para uma pasta específica depois de criá-la, como é feito neste exemplo. Para mais informações, consulte Trabalhar com pastas do Google Drive.

  1. Acesse sheets.google.com.

  2. Clique em Novo Plus.

    A planilha será criada e aberta. Cada planilha tem um valor de spreadsheetId exclusivo que contém letras, números, hífens ou sublinhados. Você pode encontrar o ID da planilha em um URL do app Planilhas Google:

    https://docs.google.com/spreadsheets/d/spreadsheetId/edit#gid=0

  3. Anote esse ID, porque ele será necessário ao criar o fluxo de trabalho.

  4. Adicione cabeçalhos de coluna para corresponder ao exemplo a seguir:

    Exemplo de planilha para registrar aprovações

    O valor na coluna G, Aprovado?, é usado para iniciar callbacks no fluxo de trabalho.

  5. Mova a planilha para a pasta do Google Drive que você criou anteriormente:

    1. Na planilha, selecione Arquivo > Mover.
    2. Acesse a pasta que você criou.
    3. Clique em Mover.

Você também pode usar o conector da API Google Sheets para criar uma planilha. Ao usar o conector, o spreadsheetId pode ser recuperado do resultado resp. Exemplo:

- create_spreadsheet:
    call: googleapis.sheets.v4.spreadsheets.create
    args:
      body:
      connector_params:
        scopes: ${driveScope}
    result: resp
- assign_sheet_id:
    assign:
      - sheetId: ${resp.spreadsheetId}

Ampliar as Planilhas Google usando o Apps Script

Com o Apps Script, é possível criar, ler e editar Planilhas Google de maneira programática. A maioria dos scripts criados para as Planilhas manipula matrizes para interagir com as células, linhas e colunas de uma planilha. Para uma introdução ao uso do Apps Script com as Planilhas Google, consulte o Guia de início rápido de funções personalizadas.

  1. Crie um projeto do Apps Script nas Planilhas Google:

    1. Abra sua planilha do Google.
    2. Selecione Extensões > Apps Script.
    3. No editor de script, clique em Projeto sem título.
    4. Dê um nome ao projeto e clique em Renomear.

    Agora, o script está vinculado à sua planilha, o que dá a ele habilidades especiais para alterar a interface do usuário ou responder quando a planilha é aberta.

    Um projeto de script representa uma coleção de arquivos e recursos do Apps Script. Os arquivos de código em um projeto de script têm uma extensão .gs.

  2. É possível usar o Apps Script para escrever funções personalizadas que podem ser usadas no Google Sheets como uma função integrada. As funções personalizadas são criadas usando JavaScript padrão. Crie uma função:

    1. Abra seu projeto do Apps Script.
    2. Clique em Editor .
    3. Um arquivo de script aparece como um arquivo de projeto chamado Code.gs. Para editar o arquivo, selecione-o.
    4. Substitua o código no editor de script pelo seguinte, que lê os dados na sua planilha e os transmite como entrada para uma execução de fluxo de trabalho:

      function handleEdit(e) {
        var range = e.range.getA1Notation();
        var sheet = e.source;
      
        if (range.length > 1 && range[0] === 'G') {
          if (e.value == "TRUE") {
            Logger.log("Approved: TRUE");
      
            var row = range.slice(1);
            var url = sheet.getRange('E' + row).getCell(1, 1).getValue();
            var approver = sheet.getRange('F' + row).getCell(1, 1).getValue();
      
            callback(url, approver);
          }
          else {
            Logger.log("Approved: FALSE");
          }
        }
      }
      
      function callback(url, approver) {
        const headers = {
          "Authorization": "Bearer " + ScriptApp.getOAuthToken()
        };
      
        var payload = {
          'approver': approver
        };
      
        const params = {
          "method": 'POST',
          "contentType": 'application/json',
          "headers": headers,
          "payload": JSON.stringify(payload)
        };
      
      
        Logger.log("Workflow callback request to " + url);
        var response = UrlFetchApp.fetch(url, params);
        Logger.log(response);
      }
    5. Clique em Salvar .

  3. Os gatilhos instaláveis do Apps Script permitem que um projeto de script execute uma função especificada quando determinadas condições são atendidas, como quando uma planilha é aberta ou editada. Crie um gatilho:

    1. Abra seu projeto do Apps Script.
    2. Clique em Acionadores .
    3. Clique em Adicionar gatilho.
    4. Na caixa de diálogo Adicionar gatilho para YOUR_PROJECT_NAME, configure o gatilho:
      1. Na lista Escolha a função que será executada, selecione handleEdit.
      2. Na lista Escolha qual implantação deve ser executada, selecione Head.
      3. Na lista Selecionar origem do evento, escolha Da planilha.
      4. Na lista Selecionar tipo de evento, escolha Ao editar.
      5. Na lista Configurações de notificação de falha, selecione Me notificar diariamente.
    5. Clique em Salvar.
    6. Se você receber uma solicitação para escolher uma Conta do Google, selecione a conta apropriada e clique em Permitir.

      Isso permite que seu projeto do Apps Script veja, edite, crie e exclua suas planilhas Google; e se conecte a um serviço externo.

  4. Um arquivo de manifesto do projeto do Apps Script é um arquivo JSON que especifica informações básicas do projeto que o Apps Script precisa para executar um script com sucesso. O editor do Apps Script oculta os arquivos de manifesto por padrão para proteger as configurações do projeto do Apps Script. Edite o arquivo de manifesto:

    1. Abra seu projeto do Apps Script.
    2. Clique em Configurações do projeto .
    3. Selecione a caixa de seleção Mostrar arquivo de manifesto "appsscript.json" no editor.
    4. Clique em Editor .
    5. O arquivo de manifesto aparece como um arquivo de projeto chamado appsscript.json. Para editar o arquivo, selecione-o.
    6. O campo oauthScopes especifica uma matriz de strings. Para definir os escopos de autorização que seu projeto usa, adicione uma matriz com os escopos que você quer oferecer suporte. Exemplo:

      {
        "timeZone": "America/Toronto",
        "dependencies": {
        },
        "exceptionLogging": "STACKDRIVER",
        "runtimeVersion": "V8",
        "oauthScopes": [
          "https://www.googleapis.com/auth/script.external_request",
          "https://www.googleapis.com/auth/cloud-platform",
          "https://www.googleapis.com/auth/spreadsheets"
        ]
      }

      Isso define escopos explícitos para:

      • Conectar a um serviço externo
      • Ver, editar, configurar e excluir seus Google Cloud dados e consultar o endereço de e-mail da sua Conta do Google
      • Ver, editar, criar e excluir todas as suas planilhas do Planilhas Google
    7. Clique em Salvar .

Implantar um fluxo de trabalho que grava em uma planilha e usa callbacks

Implante um fluxo de trabalho que executa, pausa e retoma quando um callback é aprovado em uma planilha. O fluxo de trabalho grava em uma planilha do Google usando o conector da API Google Sheets.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho:

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Insira um nome para o novo fluxo de trabalho: workflows-awaits-callback-sheets.

  4. Na lista Região, selecione us-central1 (Iowa).

  5. Em Conta de serviço, selecione a conta de serviço padrão do Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com).

  6. Clique em Próxima.

  7. No editor de fluxo de trabalho, insira a seguinte definição:

    main:
      steps:
        - init:
            assign:
            # Replace with your sheetId and make sure the service account
            # for the workflow has write permissions to the sheet
            - sheetId: "10hieAH6b-oMeIVT_AerSLNxQck14IGhgi8ign-x2x8g"
        - before_sheets_callback:
            call: sys.log
            args:
              severity: INFO
              data: ${"Execute steps here before waiting for callback from sheets"}
        - wait_for_sheets_callback:
            call: await_callback_sheets
            args:
              sheetId: ${sheetId}
            result: await_callback_result
        - after_sheets_callback:
            call: sys.log
            args:
              severity: INFO
              data: ${"Execute steps here after receiving callback from sheets"}
        - returnResult:
            return: ${await_callback_result}
    
    await_callback_sheets:
        params: [sheetId]
        steps:
            - init:
                assign:
                  - project_id: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                  - location: ${sys.get_env("GOOGLE_CLOUD_LOCATION")}
                  - workflow_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_ID")}
                  - execution_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_EXECUTION_ID")}
            - create_callback:
                call: events.create_callback_endpoint
                args:
                  http_callback_method: POST
                result: callback_details
            - save_callback_to_sheets:
                call: googleapis.sheets.v4.spreadsheets.values.append
                args:
                    range: ${"Sheet1!A1:G1"}
                    spreadsheetId: ${sheetId}
                    valueInputOption: RAW
                    body:
                        majorDimension: "ROWS"
                        values:
                          - ["${project_id}", "${location}", "${workflow_id}", "${execution_id}", "${callback_details.url}", "", "FALSE"]
            - log_and_await_callback:
                try:
                  steps:
                    - log_await_start:
                        call: sys.log
                        args:
                          severity: INFO
                          data: ${"Started waiting for callback from sheet " + sheetId}
                    - await_callback:
                        call: events.await_callback
                        args:
                          callback: ${callback_details}
                          timeout: 3600
                        result: callback_request
                    - log_await_stop:
                        call: sys.log
                        args:
                          severity: INFO
                          data: ${"Stopped waiting for callback from sheet " + sheetId}
                except:
                    as: e
                    steps:
                        - log_error:
                            call: sys.log
                            args:
                                severity: "ERROR"
                                text: ${"Received error " + e.message}
            - check_null_await_result:
                switch:
                  - condition: ${callback_request == null}
                    return: null
            - log_await_result:
                call: sys.log
                args:
                  severity: INFO
                  data: ${"Approved by " + callback_request.http_request.body.approver}
            - return_await_result:
                return: ${callback_request.http_request.body}
  8. Substitua o valor do marcador de posição sheetId pelo seu spreadsheetId.

  9. Clique em Implantar.

gcloud

  1. Crie um arquivo de código-fonte para o fluxo de trabalho:

    touch workflows-awaits-callback-sheets.yaml
  2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo de código-fonte:

    main:
      steps:
        - init:
            assign:
            # Replace with your sheetId and make sure the service account
            # for the workflow has write permissions to the sheet
            - sheetId: "10hieAH6b-oMeIVT_AerSLNxQck14IGhgi8ign-x2x8g"
        - before_sheets_callback:
            call: sys.log
            args:
              severity: INFO
              data: ${"Execute steps here before waiting for callback from sheets"}
        - wait_for_sheets_callback:
            call: await_callback_sheets
            args:
              sheetId: ${sheetId}
            result: await_callback_result
        - after_sheets_callback:
            call: sys.log
            args:
              severity: INFO
              data: ${"Execute steps here after receiving callback from sheets"}
        - returnResult:
            return: ${await_callback_result}
    
    await_callback_sheets:
        params: [sheetId]
        steps:
            - init:
                assign:
                  - project_id: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                  - location: ${sys.get_env("GOOGLE_CLOUD_LOCATION")}
                  - workflow_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_ID")}
                  - execution_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_EXECUTION_ID")}
            - create_callback:
                call: events.create_callback_endpoint
                args:
                  http_callback_method: POST
                result: callback_details
            - save_callback_to_sheets:
                call: googleapis.sheets.v4.spreadsheets.values.append
                args:
                    range: ${"Sheet1!A1:G1"}
                    spreadsheetId: ${sheetId}
                    valueInputOption: RAW
                    body:
                        majorDimension: "ROWS"
                        values:
                          - ["${project_id}", "${location}", "${workflow_id}", "${execution_id}", "${callback_details.url}", "", "FALSE"]
            - log_and_await_callback:
                try:
                  steps:
                    - log_await_start:
                        call: sys.log
                        args:
                          severity: INFO
                          data: ${"Started waiting for callback from sheet " + sheetId}
                    - await_callback:
                        call: events.await_callback
                        args:
                          callback: ${callback_details}
                          timeout: 3600
                        result: callback_request
                    - log_await_stop:
                        call: sys.log
                        args:
                          severity: INFO
                          data: ${"Stopped waiting for callback from sheet " + sheetId}
                except:
                    as: e
                    steps:
                        - log_error:
                            call: sys.log
                            args:
                                severity: "ERROR"
                                text: ${"Received error " + e.message}
            - check_null_await_result:
                switch:
                  - condition: ${callback_request == null}
                    return: null
            - log_await_result:
                call: sys.log
                args:
                  severity: INFO
                  data: ${"Approved by " + callback_request.http_request.body.approver}
            - return_await_result:
                return: ${callback_request.http_request.body}
  3. Substitua o valor do marcador de posição sheetId pelo seu spreadsheetId.

  4. Implante o fluxo de trabalho digitando o seguinte comando:

    gcloud workflows deploy workflows-awaits-callback-sheets \
        --source=workflows-awaits-callback-sheets.yaml \
        --location=us-central1 \
        --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com

    Substitua PROJECT_NUMBER pelo número do seu projeto Google Cloud. Para recuperar o número do projeto:

    gcloud projects describe PROJECT_ID

Testar o fluxo completo

Execute o fluxo de trabalho para testar o fluxo completo. Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho:

    Acessar fluxos de trabalho

  2. Na página Fluxos de trabalho, selecione o fluxo workflows-awaits-callback-sheets para acessar a página de detalhes dele.

  3. Na página Detalhes do fluxo de trabalho, clique em Executar.

  4. Clique em Executar novamente.

    O fluxo de trabalho é iniciado, e o estado de execução dele deve ser Em execução. Os registros também indicam que o fluxo de trabalho está pausado e aguardando:

    Execute steps here before waiting for callback from sheets
    ...
    Started waiting for callback from sheet 1JlNFFnqs760M_KDqeeeDc_qtrABZDxoalyCmRE39dpM
  5. Verifique se o fluxo de trabalho gravou os detalhes do callback em uma linha da planilha.

    Por exemplo, você vai ver o ID de execução do fluxo de trabalho na coluna ID de execução, um endpoint de callback na coluna URL de callback e FALSE na coluna Aprovado?.

  6. Na planilha, mude FALSE para TRUE.

    Depois de um ou dois minutos, a execução será retomada e concluída com um estado de execução Concluído.

gcloud

  1. Abra um terminal.

  2. Execute o fluxo de trabalho:

      gcloud workflows run workflows-awaits-callback-sheets

    O fluxo de trabalho é iniciado, e a saída indica que ele está pausado e aguardando:

      Waiting for execution [a8361789-90e0-467f-8bd7-ea1c81977820] to complete...working.

  3. Verifique se o fluxo de trabalho gravou os detalhes do callback em uma linha da planilha.

    Por exemplo, você vai ver o ID de execução do fluxo de trabalho na coluna ID de execução, um endpoint de callback na coluna URL de callback e FALSE na coluna Aprovado?.

  4. Na planilha, mude FALSE para TRUE.

    Depois de um ou dois minutos, a execução será retomada e concluída com um estado de execução SUCCEEDED.

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.

Exclua o projeto

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

Para excluir o projeto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir recursos criados neste tutorial

  1. Excluir arquivos no Google Drive.
  2. Exclua um fluxo de trabalho.

A seguir