Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Flujos de trabajo de muestra

En esta página, se proporcionan definiciones de flujo de trabajo de muestra para ayudarte a comprender la sintaxis de flujos de trabajo y sus patrones de uso comunes.

Autenticación

Para todas las muestras que se comunican con otros recursos de Google Cloud, tu flujo de trabajo debe estar asociado con una cuenta de servicio que tenga suficientes privilegios para acceder a esos recursos. Para obtener más información sobre la concesión de funciones a las cuentas de servicio, consulta Cómo otorgar, cambiar y revocar el acceso a los recursos. Para aprender a cambiar la cuenta de servicio asociada con un flujo de trabajo, consulta cómo actualizar un flujo de trabajo. Para obtener más información sobre la autenticación, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Solicitudes HTTP

En estos ejemplos, se demuestra cómo realizar solicitudes HTTP.

Realiza una solicitud HTTP POST externa

En esta muestra, se realiza una solicitud POST a un extremo 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}"
    }
  }
]

Realiza una solicitud HTTP GET externa con encabezados

En este ejemplo, se realiza una solicitud HTTP GET con un encabezado personalizado. También puedes proporcionar definiciones de encabezado personalizadas cuando realizas otros tipos de solicitudes 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}"
    }
  }
]

Variables, expresiones y argumentos del entorno de ejecución

En estos ejemplos, se demuestra la asignación de valores a variables, la evaluación de expresiones y el acceso a argumentos de entorno de ejecución.

Cómo asignar variables

En esta muestra, se asignan valores de string y número a variables. Las asignaciones de variables se ejecutan de forma secuencial.

YAML

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

JSON

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

Cómo evaluar una expresión con conversión de tipo

En este ejemplo, se usa una expresión para asignar el valor de una variable. La variable FullName usa la variable LastName que se definió más arriba.

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}"
    }
  }
]

Accede a los argumentos del entorno de ejecución

En esta muestra, se accede a los argumentos del entorno de ejecución que se pasan al flujo de trabajo como parte de la solicitud de ejecución. Todos los argumentos se almacenan en el mismo diccionario, declarados como un parámetro del flujo de trabajo principal.

Cuando ejecutes este flujo de trabajo, pasa los argumentos del entorno de ejecución con el siguiente 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}"
        }
      }
    ]
  }
}

Declara un diccionario y un arreglo

En esta muestra se definen tanto un diccionario como algunos arreglos. Las definiciones de arreglos se pueden intercalar con corchetes o como una lista con un elemento por línea.

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"
          ]
        }
      ]
    }
  }
]

Itera a través de un arreglo

En esta muestra, se itera a través de un arreglo de strings y se concatenan. Esta definición de flujo de trabajo se puede modificar para procesar otros arreglos.

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}"
      }
    }
  }
]

Orden de los pasos

Orden implícito de pasos

En este ejemplo, se muestra el orden de pasos implícito dentro de un flujo de trabajo. De manera predeterminada, los pasos de un flujo de trabajo se ejecutan en el orden en que aparecen en la definición del flujo de trabajo.

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"
      }
    }
  }
]

Orden explícito de pasos con saltos

En esta muestra, se usa el comando next: para definir de manera explícita la secuencia de pasos del flujo de trabajo. En este ejemplo, los pasos se ejecutan en un orden diferente al que aparecen en la definición del flujo de trabajo.

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"
    }
  }
]

Si deseas obtener más información sobre cómo usar next para controlar el orden de los pasos, consulta cómo controlar el orden de ejecución en un flujo de trabajo.

Salto condicional

Hay casos en los que es posible que desees que un flujo de trabajo pase a pasos específicos cuando se cumple una condición. Esta muestra salta a los pasos small, medium o large según el valor que muestre el primer paso del flujo de trabajo.

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 obtener más información sobre el uso de interruptores, consulta saltos condicionales

Cambiar la estructura con pasos incorporados

Una estructura de cambio también se puede usar para admitir la ejecución directa de los pasos cuando se cumple una condición, sin saltar a otros pasos. Esto mejora la legibilidad de un flujo de trabajo, ya que reduce la cantidad de pasos en la definición del flujo de trabajo.

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 obtener más información sobre el uso de interruptores, consulta saltos condicionales

Subflujo de trabajo simple

En esta muestra, se implementa un subflujo de trabajo simple. Cuando un flujo de trabajo tiene un subflujo de trabajo, el flujo de trabajo principal debe colocarse en un bloque main. Los subflujos de trabajo siempre se definen después del cuerpo principal de la definición del flujo de trabajo.

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 obtener más información sobre cómo usar subflujos de trabajo, consulta cómo crear y usar un subflujo de trabajo.

Manejo de errores

En estos ejemplos, se muestra cómo detectar excepciones y volver a intentar los pasos. Consulta la sección de manejo de errores de la página de referencia de la sintaxis para obtener más detalles.

Cómo detectar y manejar errores de solicitudes HTTP

En esta muestra, se implementa un controlador de excepciones personalizado basado en el código de estado HTTP que muestra la solicitud GET. El flujo de trabajo detecta una posible excepción y muestra un mensaje de error predefinido. Si no se reconoce una excepción, la ejecución del flujo de trabajo falla y muestra la excepción como lo muestra la solicitud GET.

Se puede usar el mismo patrón para detectar excepciones que generan las cargas de trabajo de Cloud Run o 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"
    }
  }
]

Reintentar los pasos mediante una política de reintento predeterminada

Los flujos de trabajo cuentan con políticas de reintento integradas. En esta muestra, se usa una política de reintento integrada para las solicitudes HTTP.

Vuelve a intentar los pasos con una configuración personalizada

En este ejemplo, se realiza una solicitud HTTP con una configuración de reintento personalizada. En este ejemplo, se usa un predicado de reintento estándar, que determina cuándo se realiza un reintento y una cantidad máxima personalizada de reintentos y parámetros de retirada.

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
        }
      }
    }
  }
]

Manejo de errores con predicado personalizado

En esta muestra, se define un controlador de errores personalizado, que incluye un predicado personalizado y los parámetros de retirada personalizados. Un predicado se define como un subflujo de trabajo que acepta un solo parámetro como diccionario, que se usa para conservar la definición de la excepción.

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
        }
      }
    ]
  }
}

Conéctate con otros servicios de Google Cloud

En estas muestras, se demuestra cómo los flujos de trabajo pueden interactuar con otros servicios de Google Cloud.

Una solicitud POST a una función de Cloud Functions con autenticación

En esta muestra, se realiza una solicitud POST a una función de Cloud Functions que solo acepta llamadas 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 obtener más información sobre la autenticación en un recurso desde un flujo de trabajo, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Solicitud GET a Cloud Run con autenticación

En esta muestra, se invoca una carga de trabajo de Cloud Run que requiere autenticación.

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 obtener más información sobre la autenticación en un recurso desde un flujo de trabajo, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Detén una máquina virtual de Compute Engine

En esta muestra, se realiza una llamada a la API de Compute Engine para detener una máquina virtual. El ID de un proyecto se captura desde una variable de entorno integrada, que apunta al mismo proyecto que el flujo de trabajo para ayudar con la portabilidad del código fuente.

El flujo de trabajo debe estar asociado con una cuenta de servicio que tenga suficientes privilegios para detener una máquina virtual, como la función roles/compute.instanceAdmin.v1. Para obtener más información sobre la concesión de funciones a las cuentas de servicio, consulta Cómo otorgar, cambiar y revocar el acceso a los 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 obtener más información sobre la autenticación en un recurso desde un flujo de trabajo, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Lee desde Firestore

En este ejemplo, se muestra cómo realizar una solicitud a la API de Firestore para leer una entrada. El flujo de trabajo inicializa las variables a fin de establecer el ID del proyecto, el nombre de la colección y el documento que se recuperarán en el paso initialize.

El flujo de trabajo debe estar asociado con una cuenta de servicio que tenga suficientes privilegios para leer desde Firestore, como la función roles/datastore.viewer. Para obtener más información sobre la concesión de funciones a las cuentas de servicio, consulta Cómo otorgar, cambiar y revocar el acceso a los 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 obtener más información sobre la autenticación en un recurso desde un flujo de trabajo, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Escribe en Firestore

En esta muestra, se realiza una solicitud a la API de Firestore para escribir una entrada. El flujo de trabajo inicializa las variables para establecer el ID del proyecto, el nombre de la colección y el documento que se recuperará en el paso initialize.

El flujo de trabajo debe estar asociado con una cuenta de servicio que tenga suficientes privilegios para leer desde Firestore, como la función roles/datastore.user. Para obtener más información sobre la concesión de funciones a las cuentas de servicio, consulta Cómo otorgar, cambiar y revocar el acceso a los 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 obtener más información sobre la autenticación en otro recurso desde el flujo de trabajo, consulta cómo realizar solicitudes autenticadas desde un flujo de trabajo.

Traduce del inglés al ruso con la API de Cloud Translation.

Esta muestra realiza una solicitud a la API de Cloud Translation para traducir una string de argumento de entorno de ejecución de inglés a ruso.

El flujo de trabajo debe estar asociado con una cuenta de servicio que tenga suficientes privilegios para enviar solicitudes a la API de Cloud Translation, como la función roles/cloudtranslate.user. Para obtener más información sobre la concesión de funciones a las cuentas de servicio, consulta Cómo otorgar, cambiar y revocar el acceso a los recursos.

Cuando ejecutes este flujo de trabajo, pasa un argumento de entorno de ejecución con el siguiente 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}"
        }
      }
    ]
  }
}

¿Qué sigue?