Esta página foi traduzida pela API Cloud Translation.
Switch to English

Amostras de fluxos de trabalho

Nesta página, fornecemos exemplos de definições de fluxo de trabalho para ajudar você a entender a sintaxe dos fluxos de trabalho e seus padrões de uso comuns.

Autenticação

Para todas as amostras que se comunicam com outros recursos do Google Cloud, seu fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para acessar esses recursos. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos. Para saber como alterar a conta de serviço associada a um fluxo de trabalho, consulte como atualizar um fluxo de trabalho. Para mais informações sobre autenticação, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Solicitações HTTP

Essas amostras demonstram fazer solicitações HTTP.

Como fazer uma solicitação HTTP POST externa

Essa amostra faz uma solicitação POST para um endpoint HTTP externo.

YAML

- getMessage:
    call: http.post
    args:
      url: https://www.example.com/endpoint
      body:
        someVal: "Hello World"
        anotherVal: 123
    result: theMessage
- returnValue:
    return: ${theMessage.body}

JSON

[
  {
    "getMessage": {
      "call": "http.post",
      "args": {
        "url": "https://www.example.com/endpoint",
        "body": {
          "someVal": "Hello World",
          "anotherVal": 123
        }
      },
      "result": "theMessage"
    }
  },
  {
    "returnValue": {
      "return": "${theMessage.body}"
    }
  }
]

Como fazer uma solicitação HTTP GET externa com cabeçalhos

Esta amostra faz uma solicitação HTTP GET com um cabeçalho personalizado. Também é possível fornecer definições de cabeçalho personalizadas ao fazer outros tipos de solicitações HTTP.

YAML

- getMessage:
    call: http.get
    args:
      url: https://www.example.com/endpoint
      headers:
        Content-Type: "text/plain"
      query:
        someVal: "Hello World"
        anotherVal: 123
    result: theMessage
- returnValue:
    return: ${theMessage.body}

JSON

[
  {
    "getMessage": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/endpoint",
        "headers": {
          "Content-Type": "text/plain"
        },
        "query": {
          "someVal": "Hello World",
          "anotherVal": 123
        }
      },
      "result": "theMessage"
    }
  },
  {
    "returnValue": {
      "return": "${theMessage.body}"
    }
  }
]

Variáveis, expressões e argumentos de ambiente de execução

Essas amostras demonstram a atribuição de valores a variáveis, a avaliação de expressões e o acesso aos argumentos de ambiente de execução.

Como atribuir variáveis

Este exemplo atribui valores de string e número às variáveis. As atribuições de variáveis são executadas sequencialmente.

YAML

- firstStep:
    assign:
      - SomeName: "Sherlock"
      - AnotherName: "Ada"
      - SomeIntegerNumber: 27
      - SomeDoubleNumber: 4.1

JSON

[
  {
    "firstStep": {
      "assign": [
        {
          "SomeName": "Sherlock"
        },
        {
          "AnotherName": "Ada"
        },
        {
          "SomeIntegerNumber": 27
        },
        {
          "SomeDoubleNumber": 4.1
        }
      ]
    }
  }
]

Como avaliar uma expressão com cast de tipo

Esse exemplo usa uma expressão para atribuir o valor de uma variável. A variável FullName usa a variável LastName definida acima dela.

YAML

- getMessage:
    assign:
      - name: "Harsha"
      - lastName: "Kapoor"
      - fullName: ${name+" "+lastName}
      - temperatureC: 27
      - temperatureF: ${temperatureC * 9/5 + 32}
      - temperatureMsg: ${"Current temperature is "+string(temperatureF)+" F"}
- returnValue:
    return: ${temperatureMsg}

JSON

[
  {
    "getMessage": {
      "assign": [
        {
          "name": "Harsha"
        },
        {
          "lastName": "Kapoor"
        },
        {
          "fullName": "${name+\" \"+lastName}"
        },
        {
          "temperatureC": 27
        },
        {
          "temperatureF": "${temperatureC * 9/5 + 32}"
        },
        {
          "temperatureMsg": "${\"Current temperature is \"+string(temperatureF)+\" F\"}"
        }
      ]
    }
  },
  {
    "returnValue": {
      "return": "${temperatureMsg}"
    }
  }
]

Como acessar argumentos de ambiente de execução

Essa amostra acessa os argumentos de ambiente de execução transmitidos ao fluxo de trabalho como parte da solicitação de execução. Todos os argumentos são armazenados no mesmo dicionário, declarado como um parâmetro do fluxo de trabalho principal.

Ao executar esse fluxo de trabalho, passe argumentos de ambiente de execução usando o seguinte formato:

{"firstName":"Sherlock", "lastName":"Holmes"}

YAML

main:
  params: [args]
  steps:
  - step1:
      assign:
        - outputVar: ${"Hello " + args.firstName + " " + args.lastName}
  - step2:
      return: ${outputVar}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "step1": {
          "assign": [
            {
              "outputVar": "${\"Hello \" + args.firstName + \" \" + args.lastName}"
            }
          ]
        }
      },
      {
        "step2": {
          "return": "${outputVar}"
        }
      }
    ]
  }
}

Como declarar um dicionário e uma matriz

Este exemplo define um dicionário e algumas matrizes. As definições de matriz podem ser colocadas em linha usando colchetes ou como uma lista com um item por linha.

YAML

- firstStep:
    assign:
      - myDictionary:
          name: Lila
          lastName: Barton
          birthYear: 1990
      - myArray1: [1, 2, 3]
      - myArray2:
          - 1
          - 2
          - 3
      - myArray3: ["Grzegorz", "Irina", "Yufei"]

JSON

[
  {
    "firstStep": {
      "assign": [
        {
          "myDictionary": {
            "name": "Lila",
            "lastName": "Barton",
            "birthYear": 1990
          }
        },
        {
          "myArray1": [
            1,
            2,
            3
          ]
        },
        {
          "myArray2": [
            1,
            2,
            3
          ]
        },
        {
          "myArray3": [
            "Grzegorz",
            "Irina",
            "Yufei"
          ]
        }
      ]
    }
  }
]

Como iterar por uma matriz

Este exemplo itera em uma matriz de strings e as concatena em conjunto. Essa definição de fluxo de trabalho pode ser modificada para processar outras matrizes.

YAML

- define:
    assign:
      - array: ["foo", "ba", "r"]
      - result: ""
      - i: 0
- check_condition:
    switch:
      - condition: ${len(array) > i}
        next: iterate
    next: exit_loop
- iterate:
    assign:
      - result: ${result + array[i]}
      - i: ${i+1}
    next: check_condition
- exit_loop:
    return:
        concat_result: ${result}

JSON

[
  {
    "define": {
      "assign": [
        {
          "array": [
            "foo",
            "ba",
            "r"
          ]
        },
        {
          "result": ""
        },
        {
          "i": 0
        }
      ]
    }
  },
  {
    "check_condition": {
      "switch": [
        {
          "condition": "${len(array) > i}",
          "next": "iterate"
        }
      ],
      "next": "exit_loop"
    }
  },
  {
    "iterate": {
      "assign": [
        {
          "result": "${result + array[i]}"
        },
        {
          "i": "${i+1}"
        }
      ],
      "next": "check_condition"
    }
  },
  {
    "exit_loop": {
      "return": {
        "concat_result": "${result}"
      }
    }
  }
]

Ordem de passos

Ordem implícita de passos

Este exemplo mostra a ordem implícita de etapa em um fluxo de trabalho. Por padrão, as etapas de um fluxo de trabalho são executadas na ordem em que aparecem na definição do fluxo de trabalho.

YAML

- firstStep:
    call: http.get
    args:
      url: https://www.example.com/callA
- secondStep:
    call: http.get
    args:
      url: https://www.example.com/callB
- thirdStep:
    call: http.get
    args:
      url: https://www.example.com/callC

JSON

[
  {
    "firstStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/callA"
      }
    }
  },
  {
    "secondStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/callB"
      }
    }
  },
  {
    "thirdStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/callC"
      }
    }
  }
]

Ordem explícita de passos usando saltos

Este exemplo usa o comando next: para definir explicitamente a sequência de etapas do fluxo de trabalho. Neste exemplo, as etapas são executadas em uma ordem diferente da exibida na definição do fluxo de trabalho.

YAML

- firstStep:
    call: http.get
    args:
      url: https://www.somewhere.com/callA
    next: secondStep
- thirdStep:
    call: http.get
    args:
      url: https://www.somewhere.com/callB
    next: end
- secondStep:
    call: http.get
    args:
      url: https://www.somewhere.com/callC
    next: thirdStep

JSON

[
  {
    "firstStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.somewhere.com/callA"
      },
      "next": "secondStep"
    }
  },
  {
    "thirdStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.somewhere.com/callB"
      },
      "next": "end"
    }
  },
  {
    "secondStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.somewhere.com/callC"
      },
      "next": "thirdStep"
    }
  }
]

Para mais informações sobre como usar next para controlar a ordem das etapas, consulte como controlar a ordem de execução em um fluxo de trabalho.

Salto condicional

Há casos em que você pode querer que um fluxo de trabalho pule etapas específicas quando uma condição é atendida. Essa amostra segue para as etapas small, medium ou large, dependendo do valor retornado pela primeira etapa do fluxo de trabalho.

YAML

- firstStep:
    call: http.get
    args:
      url: https://www.example.com/callA
    result: firstResult
- whereToJump:
    switch:
      - condition: ${firstResult.body.SomeField < 10}
        next: small
      - condition: ${firstResult.body.SomeField < 100}
        next: medium
    next: large
- small:
    call: http.get
    args:
      url: https://www.example.com/SmallFunc
    next: end
- medium:
    call: http.get
    args:
      url: https://www.example.com/MediumFunc
    next: end
- large:
    call: http.get
    args:
      url: https://www.example.com/LargeFunc
    next: end

JSON

[
  {
    "firstStep": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/callA"
      },
      "result": "firstResult"
    }
  },
  {
    "whereToJump": {
      "switch": [
        {
          "condition": "${firstResult.body.SomeField < 10}",
          "next": "small"
        },
        {
          "condition": "${firstResult.body.SomeField < 100}",
          "next": "medium"
        }
      ],
      "next": "large"
    }
  },
  {
    "small": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/SmallFunc"
      },
      "next": "end"
    }
  },
  {
    "medium": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/MediumFunc"
      },
      "next": "end"
    }
  },
  {
    "large": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/LargeFunc"
      },
      "next": "end"
    }
  }
]

Para mais informações sobre como usar switches, consulte jumps condicionais.

Alternar estrutura com etapas incorporadas

Uma estrutura de chave também pode ser usada para aceitar a execução direta de etapas quando uma condição for atendida, sem pular para outras etapas. Isso melhora a legibilidade de um fluxo de trabalho reduzindo o número de etapas na definição dele.

YAML

- step1:
    assign:
      - a: 1
- step2:
    switch:
      - condition: ${a==1}
        steps:
          - stepA:
              assign:
                - a: ${a+7}
          - stepB:
              return: ${"increase a to:"+string(a)}
- step3:
    return: ${"default a="+string(a)}

JSON

[
  {
    "step1": {
      "assign": [
        {
          "a": 1
        }
      ]
    }
  },
  {
    "step2": {
      "switch": [
        {
          "condition": "${a==1}",
          "steps": [
            {
              "stepA": {
                "assign": [
                  {
                    "a": "${a+7}"
                  }
                ]
              }
            },
            {
              "stepB": {
                "return": "${\"increase a to:\"+string(a)}"
              }
            }
          ]
        }
      ]
    }
  },
  {
    "step3": {
      "return": "${\"default a=\"+string(a)}"
    }
  }
]

Para mais informações sobre como usar switches, consulte jumps condicionais.

Subfluxo de trabalho simples

Essa amostra implementa um subfluxo de trabalho simples. Quando um fluxo de trabalho tem um sub-fluxo, ele precisa ser colocado em um bloco main. Os subfluxos são sempre definidos após o corpo principal da definição do fluxo de trabalho.

YAML

main:
  steps:
    - first:
        call: hello
        args:
          input: "Kristof"
        result: someOutput
    - second:
        return: ${someOutput}

hello:
  params: [input]
  steps:
    - first:
        return: ${"Hello "+input}

JSON

{
  "main": {
    "steps": [
      {
        "first": {
          "call": "hello",
          "args": {
            "input": "Kristof"
          },
          "result": "someOutput"
        }
      },
      {
        "second": {
          "return": "${someOutput}"
        }
      }
    ]
  },
  "hello": {
    "params": [
      "input"
    ],
    "steps": [
      {
        "first": {
          "return": "${\"Hello \"+input}"
        }
      }
    ]
  }
}

Para mais informações sobre como usar subfluxos, consulte como criar e usar um subfluxo de trabalho.

Tratamento de erros

Essas amostras mostram como capturar exceções e repetir etapas. Para mais detalhes, consulte a seção sobre processamento de erros da página de referência da sintaxe.

Como capturar e processar erros de solicitação HTTP

Este exemplo implementa um gerenciador de exceção personalizado com base no código de status HTTP retornado pela solicitação GET. O fluxo de trabalho detecta uma possível exceção e retorna uma mensagem de erro predefinida. Se uma exceção não for reconhecida, a execução do fluxo de trabalho falhará e emitirá a exceção conforme retornada pela solicitação GET.

O mesmo padrão pode ser usado para capturar exceções geradas pelas cargas de trabalho do Cloud Run ou do Cloud Functions.

YAML

- readItem:
    try:
      call: http.get
      args:
        url: https://example.com/someapi
        auth:
          type: OIDC
      result: APIResponse
    except:
      as: e
      steps:
        - knownErrors:
            switch:
              - condition: ${not("HttpError" in e.tags)}
                next: connectionProblem
              - condition: ${e.code == 404}
                next: urlNotFound
              - condition: ${e.code == 403}
                next: authProblem
        - UnhandledException:
            raise: ${e}
- urlFound:
    return: ${APIResponse.body}
- connectionProblem:
    return: "Connection problem; check URL"
- urlNotFound:
    return: "Sorry, URL wasn't found"
- authProblem:
    return: "Authentication error"

JSON

[
  {
    "readItem": {
      "try": {
        "call": "http.get",
        "args": {
          "url": "https://example.com/someapi",
          "auth": {
            "type": "OIDC"
          }
        },
        "result": "APIResponse"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "knownErrors": {
              "switch": [
                {
                  "condition": "${not(\"HttpError\" in e.tags)}",
                  "next": "connectionProblem"
                },
                {
                  "condition": "${e.code == 404}",
                  "next": "urlNotFound"
                },
                {
                  "condition": "${e.code == 403}",
                  "next": "authProblem"
                }
              ]
            }
          },
          {
            "UnhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "urlFound": {
      "return": "${APIResponse.body}"
    }
  },
  {
    "connectionProblem": {
      "return": "Connection problem; check URL"
    }
  },
  {
    "urlNotFound": {
      "return": "Sorry, URL wasn't found"
    }
  },
  {
    "authProblem": {
      "return": "Authentication error"
    }
  }
]

Como repetir etapas usando uma política de nova tentativa padrão

Os fluxos de trabalho vêm com políticas de repetição integradas. Neste exemplo, usamos uma política de repetição interna para solicitações HTTP.

Como repetir etapas com configuração personalizada

Este exemplo faz uma solicitação HTTP usando uma configuração personalizada de repetição. Este exemplo usa um predicado de repetição padrão, determinando quando executar uma nova tentativa e um número máximo personalizado de tentativas e parâmetros de espera.

YAML

- readItem:
    try:
      call: http.get
      args:
        url: https://example.com/someapi
      result: apiResponse
    retry:
      predicate: ${http.default_retry_predicate}
      max_retries: 5
      backoff:
        initial_delay: 2
        max_delay: 60
        multiplier: 2

JSON

[
  {
    "readItem": {
      "try": {
        "call": "http.get",
        "args": {
          "url": "https://example.com/someapi"
        },
        "result": "apiResponse"
      },
      "retry": {
        "predicate": "${http.default_retry_predicate}",
        "max_retries": 5,
        "backoff": {
          "initial_delay": 2,
          "max_delay": 60,
          "multiplier": 2
        }
      }
    }
  }
]

Gerenciamento de erros com predicado personalizado

Esta amostra define um gerenciador de erro personalizado, incluindo um predicado personalizado e parâmetros de espera personalizados. Um predicado é definido como um subfluxo que aceita um único parâmetro como dicionário, que é usado para manter a definição da exceção.

YAML

main:
  steps:
    - readItem:
        try:
          call: http.get
          args:
            url: https://example.com/someapi
          result: apiResponse
        retry:
          predicate: ${myOwnPredicate}
          max_retries: 5
          backoff:
            initial_delay: 2
            max_delay: 60
            multiplier: 2
    - LastStep:
        return: "OK"

myOwnPredicate:
  params: [e]
  steps:
    - whatToRepeat:
        switch:
          - condition: "df"
            return: True
    - otherwise:
        return: False

JSON

{
  "main": {
    "steps": [
      {
        "readItem": {
          "try": {
            "call": "http.get",
            "args": {
              "url": "https://example.com/someapi"
            },
            "result": "apiResponse"
          },
          "retry": {
            "predicate": "${myOwnPredicate}",
            "max_retries": 5,
            "backoff": {
              "initial_delay": 2,
              "max_delay": 60,
              "multiplier": 2
            }
          }
        }
      },
      {
        "LastStep": {
          "return": "OK"
        }
      }
    ]
  },
  "myOwnPredicate": {
    "params": [
      "e"
    ],
    "steps": [
      {
        "whatToRepeat": {
          "switch": [
            {
              "condition": "df",
              "return": true
            }
          ]
        }
      },
      {
        "otherwise": {
          "return": false
        }
      }
    ]
  }
}

Como se conectar com outros serviços do Google Cloud

Estas amostras demonstram como os fluxos de trabalho podem interagir com outros serviços do Google Cloud.

Solicitação POST para um Cloud Functions com autenticação

Neste exemplo, fazemos uma solicitação POST para uma função do Cloud Functions que aceita apenas chamadas autenticadas.

YAML

- callMyFunction:
    call: http.post
    args:
      url: https://us-central1-myproject123.cloudfunctions.net/myfunc1
      auth:
        type: OIDC
      body:
        someVal: "Hello World"
        anotherVal: 123
    result: theMessage
- returnValue:
    return: ${theMessage.body}

JSON

[
  {
    "callMyFunction": {
      "call": "http.post",
      "args": {
        "url": "https://us-central1-myproject123.cloudfunctions.net/myfunc1",
        "auth": {
          "type": "OIDC"
        },
        "body": {
          "someVal": "Hello World",
          "anotherVal": 123
        }
      },
      "result": "theMessage"
    }
  },
  {
    "returnValue": {
      "return": "${theMessage.body}"
    }
  }
]

Para mais informações sobre como autenticar um recurso em um fluxo de trabalho, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Solicitação GET para o Cloud Run com autenticação

Este exemplo invoca uma carga de trabalho do Cloud Run que requer autenticação.

YAML

- callMyFunction:
    call: http.get
    args:
      url: https://example-12345-ew.a.run.app
      auth:
        type: OIDC
      query:
        someVal: "Hello World"
        anotherVal: 123
    result: theMessage
- returnValue:
    return: ${theMessage.body}

JSON

[
  {
    "callMyFunction": {
      "call": "http.get",
      "args": {
        "url": "https://example-12345-ew.a.run.app",
        "auth": {
          "type": "OIDC"
        },
        "query": {
          "someVal": "Hello World",
          "anotherVal": 123
        }
      },
      "result": "theMessage"
    }
  },
  {
    "returnValue": {
      "return": "${theMessage.body}"
    }
  }
]

Para mais informações sobre como autenticar um recurso em um fluxo de trabalho, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Como interromper uma máquina virtual do Compute Engine

Este exemplo faz uma chamada à API Compute Engine para interromper uma máquina virtual. O ID de um projeto é capturado de uma variável de ambiente integrada, apontando para o mesmo projeto do fluxo de trabalho para ajudar na portabilidade do código-fonte.

O fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para interromper uma máquina virtual, como o papel roles/compute.instanceAdmin.v1. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos.

YAML

- initialize:
    assign:
    - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_NUMBER")}
    - zone: "us-central1-a"
    - vmToStop: "examplevm"
- stopInstance:
    call: http.post
    args:
      url: ${"https://compute.googleapis.com/compute/v1/projects/"+project+"/zones/"+zone+"/instances/"+vmToStop+"/stop"}
      auth:
        type: OAuth2
    result: stopResult

JSON

[
  {
    "initialize": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_NUMBER\")}"
        },
        {
          "zone": "us-central1-a"
        },
        {
          "vmToStop": "examplevm"
        }
      ]
    }
  },
  {
    "stopInstance": {
      "call": "http.post",
      "args": {
        "url": "${\"https://compute.googleapis.com/compute/v1/projects/\"+project+\"/zones/\"+zone+\"/instances/\"+vmToStop+\"/stop\"}",
        "auth": {
          "type": "OAuth2"
        }
      },
      "result": "stopResult"
    }
  }
]

Para mais informações sobre como autenticar um recurso em um fluxo de trabalho, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Como ler do Firestore

Esta amostra ilustra como fazer uma solicitação à API do Firestore para ler uma entrada. O fluxo de trabalho inicializa variáveis para definir o ID do projeto, o nome da coleção e o documento a ser recuperado na etapa initialize.

O fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para ler o Firestore, como o papel roles/datastore.viewer. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos.

YAML

- initialize:
    assign:
    - project: "myproject123"
    - collection: "myEntries"
    - document: "Report"
- readItem:
    try:
      call: http.get
      args:
        url: ${"https://firestore.googleapis.com/v1/projects/"+project+"/databases/(default)/documents/"+collection+"/"+document}
        auth:
          type: OAuth2
      result: documentValue
    except:
      as: e
      steps:
      - isTheKeyFound:
          switch:
          - condition: ${e.code == 404}
            next: documentNotFound
          - condition: ${e.code == 403}
            next: authError
    next: documentFound
- documentNotFound:
    return: "Document not found."
- authError:
    return: "Authentication error."
- documentFound:
    return: ${documentValue.body.fields.LastName.stringValue}

JSON

[
  {
    "initialize": {
      "assign": [
        {
          "project": "myproject123"
        },
        {
          "collection": "myEntries"
        },
        {
          "document": "Report"
        }
      ]
    }
  },
  {
    "readItem": {
      "try": {
        "call": "http.get",
        "args": {
          "url": "${\"https://firestore.googleapis.com/v1/projects/\"+project+\"/databases/(default)/documents/\"+collection+\"/\"+document}",
          "auth": {
            "type": "OAuth2"
          }
        },
        "result": "documentValue"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "isTheKeyFound": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "next": "documentNotFound"
                },
                {
                  "condition": "${e.code == 403}",
                  "next": "authError"
                }
              ]
            }
          }
        ]
      },
      "next": "documentFound"
    }
  },
  {
    "documentNotFound": {
      "return": "Document not found."
    }
  },
  {
    "authError": {
      "return": "Authentication error."
    }
  },
  {
    "documentFound": {
      "return": "${documentValue.body.fields.LastName.stringValue}"
    }
  }
]

Para mais informações sobre como autenticar um recurso em um fluxo de trabalho, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Gravação no Firestore

Esta amostra faz uma solicitação à API Firestore para gravar uma entrada. O fluxo de trabalho inicializa variáveis para definir o código do projeto, o nome da coleção e o documento a ser recuperado na etapa initialize.

O fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para ler o Firestore, como o papel roles/datastore.user. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos.

YAML

- initialize:
    assign:
    - project: "myproject123"
    - collection: "myEntries"
    - document: "Visits"
- writeItem:
    call: http.request
    args:
      url: ${"https://firestore.googleapis.com/v1/projects/"+project+"/databases/(default)/documents/"+collection+"/"+document}
      auth:
        type: OAuth2
      method: PATCH
      body:
        name: ${"projects/"+project+"/databases/(default)/documents/"+collection+"/"+document}
        fields:
          Counter:
            integerValue: 7

JSON

[
  {
    "initialize": {
      "assign": [
        {
          "project": "myproject123"
        },
        {
          "collection": "myEntries"
        },
        {
          "document": "Visits"
        }
      ]
    }
  },
  {
    "writeItem": {
      "call": "http.request",
      "args": {
        "url": "${\"https://firestore.googleapis.com/v1/projects/\"+project+\"/databases/(default)/documents/\"+collection+\"/\"+document}",
        "auth": {
          "type": "OAuth2"
        },
        "method": "PATCH",
        "body": {
          "name": "${\"projects/\"+project+\"/databases/(default)/documents/\"+collection+\"/\"+document}",
          "fields": {
            "Counter": {
              "integerValue": 7
            }
          }
        }
      }
    }
  }
]

Para mais informações sobre como autenticar em outro recurso de um fluxo de trabalho, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Traduzir do inglês para o russo com a API Cloud Translation

Neste exemplo, uma solicitação é feita à API Cloud Translation para traduzir uma string de argumentos de ambiente de execução do inglês para o russo.

O fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para enviar solicitações à API Cloud Translation, como o papel roles/cloudtranslate.user. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos.

Ao executar esse fluxo de trabalho, passe um argumento de ambiente de execução no seguinte formato:

{"textToTranslate":"Hello world!"}

YAML

main:
  params: [args]
  steps:
    - newTranslation:
        call: http.post
        args:
          url: ${"https://translation.googleapis.com/v3/projects/"+sys.get_env("GOOGLE_CLOUD_PROJECT_NUMBER")+":translateText"}
          auth:
            type: OAuth2
          body:
            contents: ${args.textToTranslate}
            sourceLanguageCode: "en-US"
            targetLanguageCode: "ru-RU"
        result: translateResponse
    - assignTranslation:
        assign:
          - translationResult: ${translateResponse.body.translations[0].translatedText}
    - returnResult:
        return: ${translationResult}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "newTranslation": {
          "call": "http.post",
          "args": {
            "url": "${\"https://translation.googleapis.com/v3/projects/\"+sys.get_env(\"GOOGLE_CLOUD_PROJECT_NUMBER\")+\":translateText\"}",
            "auth": {
              "type": "OAuth2"
            },
            "body": {
              "contents": "${args.textToTranslate}",
              "sourceLanguageCode": "en-US",
              "targetLanguageCode": "ru-RU"
            }
          },
          "result": "translateResponse"
        }
      },
      {
        "assignTranslation": {
          "assign": [
            {
              "translationResult": "${translateResponse.body.translations[0].translatedText}"
            }
          ]
        }
      },
      {
        "returnResult": {
          "return": "${translationResult}"
        }
      }
    ]
  }
}

A seguir