Realiza una solicitud HTTP

Puedes definir un paso del flujo de trabajo que realice una llamada HTTP y asignar la respuesta de la llamada a una variable. Por ejemplo, puedes invocar una instancia de Google Cloud servicio como Cloud Functions o Cloud Run a través de una solicitud HTTP.

Nota: No se debe invocar un servicio de Google Cloud a través de una solicitud HTTP. confundirse con el uso de conectores de Workflows para realizar operaciones de API que integren tu flujo de trabajo en otros productos de Google Cloud.

Invoca un extremo HTTP

Este tipo de paso te permite realizar una solicitud HTTP. HTTP y HTTPS solicitudes son compatibles. Los métodos de solicitud HTTP más comunes tienen una llamada (como http.get) y http.post), pero puedes hacer que cualquier tipo de solicitud HTTP. Para ello, establece el campo call en http.request y y especifica el tipo de solicitud con el campo method.

YAML

  - STEP_NAME:
      call: HTTP_REQUEST
      args:
          url: URL_VALUE
          method: REQUEST_METHOD
          private_service_name: "REGISTERED_SERVICE"
          headers:
              HEADER_KEY:HEADER_VALUE
              ...
          body:
              BODY_KEY:BODY_VALUE
              ...
          query:
              QUERY_KEY:QUERY_VALUE
              ...
          auth:
              type: AUTH_TYPE
              scope: AUTH_SCOPE
              scopes: AUTH_SCOPE
              audience: AUDIENCE
          timeout: TIMEOUT_IN_SECONDS
      result: RESULT_VALUE
    

JSON

  [
    {
      "STEP_NAME": {
        "call": "HTTP_REQUEST",
        "args": {
          "url": "URL_VALUE",
          "method": "REQUEST_METHOD",
          "private_service_name": "REGISTERED_SERVICE",
          "headers": {"HEADER_KEY":"HEADER_VALUE",
          ...
          },
          "body": {"BODY_KEY":"BODY_VALUE",
          ...
          },
          "query": {"QUERY_KEY":"QUERY_VALUE",
          ...
          },
          "auth": {
            "type":"AUTH_TYPE",
            "scope":"AUTH_SCOPE",
            "scopes":"AUTH_SCOPE",
            "audience":"AUDIENCE"
          },
          "timeout": "TIMEOUT_IN_SECONDS"
        },
        "result": "RESULT_VALUE"
      }
    }
  ]
    

Reemplaza lo siguiente:

• HTTP_REQUEST: obligatorio. Usa una de las siguientes opciones para solicitudes HTTP:
  • http.delete
  • http.get
  • http.patch
  • http.post
  • http.put
  • http.request
• URL_VALUE: obligatorio. URL a la que se envía la solicitud
• REQUEST_METHOD (obligatorio si se usa el tipo de llamada) http.request El tipo de método de solicitud HTTP que se usará. Por ejemplo:
  • GET
  • POST
  • PATCH
  • DELETE
• REGISTERED_SERVICE: es opcional. Una cuenta registrada Es el nombre del servicio del Directorio de servicios en el formato. projects/PROJECT_ID/locations/LOCATION/namespaces/NAMESPACE_NAME/services/SERVICE_NAME. Para obtener más información, consulta Invoque un Extremo privado compatible con los Controles del servicio de VPC.
• HEADER_KEY:HEADER_VALUE opcional. Campos de encabezado para proporcionar entradas a la API.

  Si usas un encabezado Content-Type para especificar la tipo de medio del cuerpo de la solicitud, solo se admiten los siguientes tipos:

  • application/json o application/type+json: debe ser un mapa
  • application/x-www-form-urlencoded: Debe ser un valor sin codificación. cadena
  • text/type: Debe ser una cadena.

  Si se especifica un encabezado Content-Type, el cuerpo se se codificarán según las instrucciones. Por ejemplo, puede estar codificado en formato JSON o en URL.

  Si usas un encabezado User-Agent para identificar que solicita el usuario-agente, se aplican las siguientes condiciones:

  • El valor predeterminado es GoogleCloudWorkflows; (+https://cloud.google.com/workflows/docs)
  • Si se especifica un valor, GoogleCloudWorkflows; (+https://cloud.google.com/workflows/docs) se agrega a ese valor

    Por ejemplo, User-Agent: "MY_USER_AGENT_VALUE" se especifica el encabezado de la solicitud HTTP, el encabezado de la solicitud HTTP sería el siguiente (con un espacio entre el valor especificado y el valor predeterminado agregado):

    MY_USER_AGENT_VALUE GoogleCloudWorkflows; (+https://cloud.google.com/workflows/docs)

• BODY_KEY:BODY_VALUE opcional. Campos del cuerpo para proporcionar entradas a la API.

  Si no se especifica un encabezado Content-Type y si se trata de una solicitud body, se aplica lo siguiente:

  • Si el valor del cuerpo es bytes, el encabezado se establece en Content-Type: application/octet-stream.
  • De lo contrario, el cuerpo estará codificado en JSON y el encabezado se configurará como Content-Type: application/json; charset=utf-8.
  El siguiente ejemplo muestra una estructura de cuerpo equivalente a una carga útil de JSON:

  YAML

  body:
    requests:
    - image:
        source:
          gcsImageUri: ${gsUri}
      features:
      - type: LABEL_DETECTION
      - type: SAFE_SEARCH_DETECTION
      - type: IMAGE_PROPERTIES
  result: imageAnalysisResponse

  JSON

  {
    "requests":[
      {
        "image": {
          "source": {
              "gcsUri": "img.png"
          }
        },
        "features": [
          { "type":"LABEL_DETECTION" },
          { "type":"SAFE_SEARCH_DETECTION" },
          { "type":"IMAGE_PROPERTIES" },
        ]
      }
    ]
  }

• QUERY_KEY:QUERY_VALUE opcional. Campos de consulta para proporcionar entradas a la API.
• AUTH_TYPE: es opcional. Obligatorio si la API que se requiere autenticación. Usa OIDC o OAuth2 Para obtener más información, consulta Autenticación solicitudes de un flujo de trabajo.
  • AUTH_SCOPE: es opcional. Limita el ancho de banda de una aplicación acceso a la cuenta de un usuario. Usa la tecla scope o scopes.

    La clave scope admite una cadena o una lista de cadenas. Por ejemplo:

    "https://www.googleapis.com/auth/cloud-platform"

    o

    ["https://www.googleapis.com/auth/cloud-platform", "scope2", "scope3"]

    La clave scopes, además de admitir un o una lista de cadenas, admite cadenas separadas por comas y espacios. Por ejemplo:

    "https://www.googleapis.com/auth/cloud-platform scope2 scope3"

    o

    "https://www.googleapis.com/auth/cloud-platform,scope2,scope3"

    Para obtener más información, consulta Alcances de OAuth 2.0 para las APIs de Google

  • AUDIENCE: es opcional. Especifica el público para el token de OIDC. De forma predeterminada, se establece en el mismo valor que url. Sin embargo, debes establecerla en la URL raíz de tu servicio. Por ejemplo: https://region-project.cloudfunctions.net/hello_world.
• TIMEOUT_IN_SECONDS: es opcional. Cuánto tiempo en segundos una solicitud puede ejecutarse antes de arrojar una excepción. La cantidad máxima es 1,800 segundos.
• RESULT_VALUE: es opcional. Nombre de la variable donde el de un paso de invocación HTTP.

Accede a los datos de respuesta HTTP guardados en una variable

Si el encabezado Content-Type de la respuesta especifica un tipo de medio application/json, la respuesta JSON que se almacena en un variable se convierte automáticamente en un mapa al que se puede acceder.

Si es necesario, modifica la API a la que se llama para especificar un Tipo de medio application/json para Content-Type encabezado de respuesta. De lo contrario, puedes usar el json.decode y las funciones text.encode para y convertir el cuerpo de la respuesta en un mapa. Por ejemplo:

json.decode(text.encode(RESPONSE_FROM_API))

Workflows incluye un analizador integrado para acceder a estos datos. Cómo acceder los campos de la respuesta HTTP, usa la siguiente sintaxis:

${VARIABLE_NAME.body|code|headers.PATH_TO_FIELD}

Reemplaza lo siguiente:

• VARIABLE_NAME: Es el nombre de la variable del flujo de trabajo en la que guardaste una respuesta JSON.
• body: Usa el campo body para acceder al cuerpo de la respuesta HTTP.
• code: Usa el campo code para acceder al código de respuesta HTTP.
• headers: Usa el campo headers para acceder a los encabezados de respuesta HTTP por nombre.
• PATH_TO_FIELD: Es la ruta de acceso al campo en el archivo JSON. respuesta a la que quieres acceder. Puede ser simplemente el nombre del campo o si el está anidado dentro de un objeto, puede tener la forma object1.object2.field.

Por ejemplo, si una API muestra {"age":50} y un flujo de trabajo almacena esa respuesta en una variable llamada age_response, el siguiente ejemplo muestra el valor de el campo age En este caso, 50:

age_response.body.age

Muestras

En estos ejemplos, se demuestra la sintaxis.

Asigna la respuesta de una llamada a la API

A menos que ingreses tu propio término de búsqueda, esta muestra usa tus Google Cloud para construir un término de búsqueda, que pasa al API de Wikipedia: R se mostrará una lista de artículos de Wikipedia relacionados.

YAML

main:
  params: [input]
  steps:
    - checkSearchTermInInput:
        switch:
          - condition: '${"searchTerm" in input}'
            assign:
              - searchTerm: '${input.searchTerm}'
            next: readWikipedia
    - getLocation:
        call: sys.get_env
        args:
          name: GOOGLE_CLOUD_LOCATION
        result: location
    - setFromCallResult:
        assign:
          - searchTerm: '${text.split(location, "-")[0]}'
    - readWikipedia:
        call: http.get
        args:
          url: 'https://en.wikipedia.org/w/api.php'
          query:
            action: opensearch
            search: '${searchTerm}'
        result: wikiResult
    - returnOutput:
        return: '${wikiResult.body[1]}'

JSON

{
  "main": {
    "params": [
      "input"
    ],
    "steps": [
      {
        "checkSearchTermInInput": {
          "switch": [
            {
              "condition": "${\"searchTerm\" in input}",
              "assign": [
                {
                  "searchTerm": "${input.searchTerm}"
                }
              ],
              "next": "readWikipedia"
            }
          ]
        }
      },
      {
        "getLocation": {
          "call": "sys.get_env",
          "args": {
            "name": "GOOGLE_CLOUD_LOCATION"
          },
          "result": "location"
        }
      },
      {
        "setFromCallResult": {
          "assign": [
            {
              "searchTerm": "${text.split(location, \"-\")[0]}"
            }
          ]
        }
      },
      {
        "readWikipedia": {
          "call": "http.get",
          "args": {
            "url": "https://en.wikipedia.org/w/api.php",
            "query": {
              "action": "opensearch",
              "search": "${searchTerm}"
            }
          },
          "result": "wikiResult"
        }
      },
      {
        "returnOutput": {
          "return": "${wikiResult.body[1]}"
        }
      }
    ]
  }
}

Realiza una solicitud POST de HTTP externa

En esta muestra, se realiza una solicitud POST a un extremo HTTP externo.

YAML

- send_message:
    call: http.post
    args:
      url: https://www.example.com/endpoint
      body:
        some_val: "Hello World"
        another_val: 123
    result: the_message
- return_value:
    return: ${the_message.body}

JSON

[
  {
    "send_message": {
      "call": "http.post",
      "args": {
        "url": "https://www.example.com/endpoint",
        "body": {
          "some_val": "Hello World",
          "another_val": 123
        }
      },
      "result": "the_message"
    }
  },
  {
    "return_value": {
      "return": "${the_message.body}"
    }
  }
]

Realiza una solicitud GET HTTP externa con encabezados

En esta muestra, se realiza una solicitud GET HTTP con un encabezado personalizado. También puedes proporcionar definiciones de encabezados personalizados cuando se realizan otros tipos de solicitudes HTTP.

YAML

- get_message:
    call: http.get
    args:
      url: https://www.example.com/endpoint
      headers:
        Content-Type: "text/plain"
      query:
        some_val: "Hello World"
        another_val: 123
    result: the_message
- return_value:
    return: ${the_message.body}

JSON

[
  {
    "get_message": {
      "call": "http.get",
      "args": {
        "url": "https://www.example.com/endpoint",
        "headers": {
          "Content-Type": "text/plain"
        },
        "query": {
          "some_val": "Hello World",
          "another_val": 123
        }
      },
      "result": "the_message"
    }
  },
  {
    "return_value": {
      "return": "${the_message.body}"
    }
  }
]

Usa OIDC para la autenticación cuando se realice una solicitud a Cloud Functions

En esta muestra, se agrega una sección auth al archivo OIDC para realizar una solicitud HTTP Sección args de la definición del flujo de trabajo, después de especificar la URL.

YAML

- call_my_function:
    call: http.post
    args:
      url: https://us-central1-myproject123.cloudfunctions.net/myfunc1
      auth:
        type: OIDC
      body:
        some_val: "Hello World"
        another_val: 123
    result: the_message
- return_value:
    return: ${the_message.body}

JSON

[
  {
    "call_my_function": {
      "call": "http.post",
      "args": {
        "url": "https://us-central1-myproject123.cloudfunctions.net/myfunc1",
        "auth": {
          "type": "OIDC"
        },
        "body": {
          "some_val": "Hello World",
          "another_val": 123
        }
      },
      "result": "the_message"
    }
  },
  {
    "return_value": {
      "return": "${the_message.body}"
    }
  }
]

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 devuelve la solicitud GET. El flujo de trabajo detecta una posible excepción y devuelve un mensaje de error predefinido. Si no se reconoce una excepción, el la ejecución del flujo de trabajo falla y arroja la excepción como lo muestra GET para cada solicitud. Para ver otras etiquetas de error, consulta Errores de flujo de trabajo.

YAML

# Use a custom exception handler to catch exceptions and return predefined
# error messages; if the exception isn't recognized, the workflow
# execution fails and throws the exception returned by the GET request
- read_item:
    try:
      call: http.get
      args:
        url: https://example.com/someapi
        auth:
          type: OIDC
      result: API_response
    except:
      as: e
      steps:
        - known_errors:
            switch:
              - condition: ${not("HttpError" in e.tags)}
                next: connection_problem
              - condition: ${e.code == 404}
                next: url_not_found
              - condition: ${e.code == 403}
                next: auth_problem
        - unhandled_exception:
            raise: ${e}
- url_found:
    return: ${API_response.body}
- connection_problem:
    return: "Connection problem; check URL"
- url_not_found:
    return: "Sorry, URL wasn't found"
- auth_problem:
    return: "Authentication error"

JSON

[
  {
    "read_item": {
      "try": {
        "call": "http.get",
        "args": {
          "url": "https://example.com/someapi",
          "auth": {
            "type": "OIDC"
          }
        },
        "result": "API_response"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "known_errors": {
              "switch": [
                {
                  "condition": "${not(\"HttpError\" in e.tags)}",
                  "next": "connection_problem"
                },
                {
                  "condition": "${e.code == 404}",
                  "next": "url_not_found"
                },
                {
                  "condition": "${e.code == 403}",
                  "next": "auth_problem"
                }
              ]
            }
          },
          {
            "unhandled_exception": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "url_found": {
      "return": "${API_response.body}"
    }
  },
  {
    "connection_problem": {
      "return": "Connection problem; check URL"
    }
  },
  {
    "url_not_found": {
      "return": "Sorry, URL wasn't found"
    }
  },
  {
    "auth_problem": {
      "return": "Authentication error"
    }
  }
]

¿Qué sigue?

• Instructivo para usar flujos de trabajo con Cloud Run y Cloud Functions
• Invoca un extremo privado que cumpla con los Controles del servicio de VPC
• Invoca un extremo privado local, de Compute Engine, de GKE o a otro extremo habilitando IAP
• Referencia de la sintaxis de flujos de trabajo