Esta página se ha traducido con Cloud Translation API.

Configurar plantillas Flex

En esta página se documentan varias opciones de configuración de plantillas Flex de Dataflow, entre las que se incluyen las siguientes:

Permisos
Variables de entorno de Dockerfile
Dependencias de paquetes de Python
Imágenes de Docker
Opciones de flujo de procesamiento
Ubicaciones provisionales y de almacenamiento temporal

Para configurar una plantilla Flex de ejemplo, consulta el tutorial de plantillas Flex.

Información sobre los permisos de las plantillas Flex

Cuando trabajas con plantillas Flex, necesitas tres conjuntos de permisos:

Permisos para crear recursos
Permisos para crear una plantilla Flex
Permisos para ejecutar una plantilla Flex

Permisos para crear recursos

Para desarrollar y ejecutar una canalización de plantilla flexible, debe crear varios recursos (por ejemplo, un bucket de staging). Para las tareas de creación de recursos puntuales, puedes usar el rol de propietario básico.

Permisos para crear una plantilla Flex

Como desarrollador de una plantilla flex, debes crearla para que esté disponible para los usuarios. Para crear un elemento, debes subir una especificación de plantilla a un segmento de Cloud Storage y aprovisionar una imagen de Docker con el código y las dependencias necesarios para ejecutar la canalización. Para crear una plantilla flexible, debe tener acceso de lectura y escritura a Cloud Storage y acceso de escritura a Artifact Registry a su repositorio de Artifact Registry. Para conceder estos permisos, asigna los siguientes roles:

Administrador de almacenamiento (roles/storage.admin)
Editor de versiones de Cloud (roles/cloudbuild.builds.editor)
Escritor de Artifact Registry (roles/artifactregistry.writer)

Permisos para ejecutar una plantilla Flex

Cuando ejecutas una plantilla flexible, Dataflow crea una tarea. Para crear el trabajo, la cuenta de servicio de Dataflow necesita el siguiente permiso:

dataflow.serviceAgent

Cuando usas Dataflow por primera vez, el servicio te asigna este rol, por lo que no tienes que conceder este permiso.

De forma predeterminada, la cuenta de servicio de Compute Engine se usa en las VMs de inicio y de trabajador. La cuenta de servicio necesita los siguientes roles y funciones:

Administrador de objetos de Storage (roles/storage.objectAdmin)
Lector (roles/viewer)
Trabajador de Dataflow (roles/dataflow.worker)
Acceso de lectura y escritura al bucket de almacenamiento provisional
Acceso de lectura a la imagen de la plantilla Flex

Para conceder acceso de lectura y escritura al segmento de almacenamiento provisional, puedes usar el rol Administrador de objetos de Storage (roles/storage.objectAdmin). Para obtener más información, consulta Roles de gestión de identidades y accesos para Cloud Storage.

Para conceder acceso de lectura a la imagen de la plantilla de Flex, puedes usar el rol Lector de objetos de Storage (roles/storage.objectViewer). Para obtener más información, consulta Configurar el control de acceso.

Definir las variables de entorno obligatorias de Dockerfile

Si quieres crear tu propio Dockerfile para un trabajo de plantilla flexible, especifica las siguientes variables de entorno:

Java

Especifica FLEX_TEMPLATE_JAVA_MAIN_CLASS y FLEX_TEMPLATE_JAVA_CLASSPATH en tu Dockerfile.

ENV	Descripción	Obligatorio
`FLEX_TEMPLATE_JAVA_MAIN_CLASS`	Especifica qué clase de Java se debe ejecutar para iniciar la plantilla Flex.	SÍ
`FLEX_TEMPLATE_JAVA_CLASSPATH`	Especifica la ubicación de los archivos de clase.	SÍ
`FLEX_TEMPLATE_JAVA_OPTIONS`	Especifica las opciones de Java que se deben transferir al iniciar la plantilla Flex.	NO

Python

Especifica FLEX_TEMPLATE_PYTHON_PY_FILE en tu Dockerfile.

Para gestionar las dependencias de la canalización, define variables en tu Dockerfile, como las siguientes:

FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE
FLEX_TEMPLATE_PYTHON_PY_OPTIONS
FLEX_TEMPLATE_PYTHON_SETUP_FILE
FLEX_TEMPLATE_PYTHON_EXTRA_PACKAGES

Por ejemplo, las siguientes variables de entorno se definen en el tutorial de Streaming en Python con plantilla flexible en GitHub:

ENV FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE="${WORKDIR}/requirements.txt"
ENV FLEX_TEMPLATE_PYTHON_PY_FILE="${WORKDIR}/streaming_beam.py"

ENV	Descripción	Obligatorio
`FLEX_TEMPLATE_PYTHON_PY_FILE`	Especifica qué archivo de Python se debe ejecutar para iniciar la plantilla Flex.	SÍ
`FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE`	Especifica el archivo de requisitos con las dependencias de la canalización. Para obtener más información, consulta las dependencias de PyPI en la documentación de Apache Beam.	NO
`FLEX_TEMPLATE_PYTHON_SETUP_FILE`	Especifica la ruta al archivo `setup.py` del paquete de la canalización. Para obtener más información, consulta Dependencias de varios archivos en la documentación de Apache Beam.	NO
`FLEX_TEMPLATE_PYTHON_EXTRA_PACKAGES`	Especifica los paquetes que no están disponibles públicamente. Para obtener información sobre cómo usar paquetes adicionales, consulta Dependencias locales o que no son de PyPI.	NO
`FLEX_TEMPLATE_PYTHON_PY_OPTIONS`	Especifica las opciones de Python que se deben transferir al iniciar la plantilla Flex.	NO

Dependencias de paquetes de Python

Cuando una canalización de Python de Dataflow usa dependencias adicionales, es posible que tengas que configurar la plantilla flexible para instalar dependencias adicionales en las VMs de trabajador de Dataflow.

Cuando ejecutas una tarea de Dataflow de Python que usa plantillas Flex en un entorno que restringe el acceso a Internet, debes empaquetar previamente las dependencias al crear la plantilla.

Usa una de las siguientes opciones para empaquetar previamente las dependencias de Python.

Para obtener instrucciones sobre cómo gestionar las dependencias de las canalizaciones en canalizaciones de Java y Go, consulta Gestionar las dependencias de las canalizaciones en Dataflow.

Usar un archivo de requisitos y preempaquetar las dependencias con la plantilla

Si usas tu propio archivo Dockerfile para definir la imagen de la plantilla de Flex, sigue estos pasos:

Crea un archivo requirements.txt que muestre las dependencias de tu flujo de procesamiento.

COPY requirements.txt /template/
ENV FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE="/template/requirements.txt"

Instala las dependencias en la imagen de la plantilla Flex.

RUN pip install --no-cache-dir -r $FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE

Descarga las dependencias en la caché de requisitos local, que se transfiere a los trabajadores de Dataflow cuando se inicia la plantilla.
```
RUN pip download --no-cache-dir --dest /tmp/dataflow-requirements-cache -r $FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE
```

Cuando usas este método, las dependencias del archivo requirements.txt se instalan en los trabajadores de Dataflow en el tiempo de ejecución. En la pestaña de recomendaciones de la Google Cloud consola puede aparecer una estadística que indique este comportamiento. Para evitar instalar dependencias en el tiempo de ejecución, usa una imagen de contenedor personalizada.

A continuación, se muestra un ejemplo de código que usa un archivo de requisitos en FlexTemplate.

# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

FROM gcr.io/dataflow-templates-base/python3-template-launcher-base

# Configure the Template to launch the pipeline with a --requirements_file option.
# See: https://beam.apache.org/documentation/sdks/python-pipeline-dependencies/#pypi-dependencies
ENV FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE="/template/requirements.txt"
ENV FLEX_TEMPLATE_PYTHON_PY_FILE="/template/streaming_beam.py"

COPY . /template

RUN apt-get update \
    # Install any apt packages if required by your template pipeline.
    && apt-get install -y libffi-dev git \
    && rm -rf /var/lib/apt/lists/* \
    # Upgrade pip and install the requirements.
    && pip install --no-cache-dir --upgrade pip \
    # Install dependencies from requirements file in the launch environment.
    && pip install --no-cache-dir -r $FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE \
    # When FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE  option is used,
    # then during Template launch Beam downloads dependencies
    # into a local requirements cache folder and stages the cache to workers.
    # To speed up Flex Template launch, pre-download the requirements cache
    # when creating the Template.
    && pip download --no-cache-dir --dest /tmp/dataflow-requirements-cache -r $FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE

# Set this if using Beam 2.37.0 or earlier SDK to speed up job submission.
ENV PIP_NO_DEPS=True

ENTRYPOINT ["/opt/google/dataflow/python_template_launcher"]

Estructurar la canalización como un paquete y usar paquetes locales

Si usas varios archivos o módulos locales de Python, estructura tu canal como un paquete. La estructura del archivo podría ser como la siguiente:

main.py
pyproject.toml
setup.py
src/
  my_package/
    __init__.py
    my_custom_dofns_and_transforms.py
    my_pipeline_launcher.py
    other_utils_and_helpers.py

Coloca el punto de entrada de nivel superior, por ejemplo, el archivo main.py, en el directorio raíz. Coloca el resto de los archivos en una carpeta independiente del directorio src, por ejemplo, my_package.

Añade los archivos de configuración del paquete al directorio raíz con los detalles y los requisitos del paquete.

pyproject.toml

[project]
name = "my_package"
version = "package_version"
dependencies = [
  # Add list of packages (and versions) that my_package depends on.
  # Example:
  "apache-beam[gcp]==2.54.0",
]

setup.py

  """An optional setuptools configuration stub for the pipeline package.

  Use pyproject.toml to define the package. Add this file only if you must
  use the --setup_file pipeline option or the
  FLEX_TEMPLATE_PYTHON_SETUP_FILE configuration option.
  """

  import setuptools
  setuptools.setup()

Para obtener más información sobre cómo configurar tu paquete local, consulta Empaquetar proyectos de Python.

Cuando importes módulos o archivos locales para tu canalización, usa el nombre del paquete my_package como ruta de importación.
```
from my_package import word_count_transform
```

Instala el paquete de tu flujo de procesamiento en la imagen de plantilla flexible. Tu archivo Dockerfile de plantilla flexible puede incluir contenido similar al del siguiente ejemplo:

Dockerfile

ENV FLEX_TEMPLATE_PYTHON_PY_FILE="${WORKDIR}/main.py"
ENV FLEX_TEMPLATE_PYTHON_SETUP_FILE="${WORKDIR}/setup.py"

# Copy pipeline, packages and requirements.
WORKDIR ${WORKDIR}
COPY main.py .
COPY pyproject.toml .
COPY setup.py .
COPY src src

# Install local package.
RUN pip install -e .

Para ver un ejemplo que sigue el enfoque recomendado, consulta el tutorial Plantilla flexible para una canalización con dependencias y una imagen de contenedor personalizada en GitHub.

Usar un contenedor personalizado que preinstale todas las dependencias

Para evitar la instalación de dependencias en el tiempo de ejecución, usa contenedores personalizados. Esta opción es la más adecuada para las canalizaciones que se ejecutan en entornos sin acceso a Internet.

Sigue estos pasos para usar un contenedor personalizado:

Crea una imagen de contenedor personalizada que preinstale las dependencias necesarias.
Preinstala las mismas dependencias en el Dockerfile de la plantilla Flex.

Para evitar que se instalen dependencias en el tiempo de ejecución, no uses las opciones FLEX_TEMPLATE_PYTHON_REQUIREMENTS_FILE ni FLEX_TEMPLATE_PYTHON_SETUP_FILE en la configuración de tu plantilla Flex.

Una plantilla Flex Dockerfile modificada podría tener el siguiente aspecto:
```
FROM gcr.io/dataflow-templates-base/python3-template-launcher-base
ENV FLEX_TEMPLATE_PYTHON_PY_FILE="/template/main.py"
COPY . /template
# If you use a requirements file, pre-install the requirements.txt.
RUN pip install --no-cache-dir -r /template/requirements.txt
# If you supply the pipeline in a package, pre-install the local package and its dependencies.
RUN pip install -e /template
```
Cuando usas este método, haces lo siguiente:
- crear la imagen de la plantilla Flex
- crear la imagen de contenedor del SDK personalizado
- instalar las mismas dependencias en ambas imágenes
También puedes usar tu imagen de contenedor personalizada como imagen base de la plantilla Flex para reducir el número de imágenes que tienes que mantener.
Si usas la versión 2.49.0 o una anterior del SDK de Apache Beam, añade la opción de --sdk_location=container al lanzador de tu flujo de procesamiento. Con esta opción, la canalización usará el SDK de tu contenedor personalizado en lugar de descargarlo.
```
options = PipelineOptions(beam_args, save_main_session=True, streaming=True, sdk_location="container")
```

Define el parámetro sdk_container_image en el comando flex-template run. Por ejemplo:

gcloud dataflow flex-template run $JOB_NAME \
   --region=$REGION \
   --template-file-gcs-location=$TEMPLATE_PATH \
   --parameters=sdk_container_image=$CUSTOM_CONTAINER_IMAGE \
   --additional-experiments=use_runner_v2

Para obtener más información, consulta el artículo sobre cómo usar contenedores personalizados en Dataflow.

Elige una imagen base

Puedes usar una imagen base proporcionada por Google para empaquetar las imágenes de contenedor de tu plantilla con Docker. Elige la etiqueta más reciente de las imágenes base de plantillas Flex. Te recomendamos que uses una etiqueta de imagen específica en lugar de latest. Las imágenes base se alojan en gcr.io/dataflow-templates-base.

Especifica la imagen base con el siguiente formato:

gcr.io/dataflow-templates-base/IMAGE_NAME:TAG

Haz los cambios siguientes:

IMAGE_NAME: una imagen base proporcionada por Google
TAG: nombre de la versión de la imagen base, que se encuentra en la referencia de imágenes base de plantillas Flex

Usar imágenes de contenedor personalizadas

Si tu canalización usa una imagen de contenedor personalizada, te recomendamos que la uses como imagen base para tu imagen Docker de plantilla flexible. Para ello, copia el archivo binario del launcher de la plantilla Flex de la imagen base de la plantilla proporcionada por Google en tu imagen personalizada.

Un ejemplo de Dockerfile para una imagen que se puede usar tanto como imagen de contenedor de SDK personalizado como plantilla flexible podría ser el siguiente:

FROM gcr.io/dataflow-templates-base/IMAGE_NAME:TAG as template_launcher
FROM apache/beam_python3.10_sdk:2.67.0

# RUN <...Make image customizations here...>
# See: https://cloud.google.com/dataflow/docs/guides/build-container-image

# Configure the Flex Template here.
COPY --from=template_launcher /opt/google/dataflow/python_template_launcher /opt/google/dataflow/python_template_launcher
COPY my_pipeline.py /template/
ENV FLEX_TEMPLATE_PYTHON_PY_FILE="/template/my_pipeline.py"

Haz los cambios siguientes:

IMAGE_NAME: una imagen base proporcionada por Google. Por ejemplo: python311-template-launcher-base.
TAG: etiqueta de versión de la imagen base que se encuentra en la referencia de imágenes base de plantillas Flex. Para mejorar la estabilidad y solucionar problemas, no uses latest. En su lugar, fija una etiqueta de versión específica.

Para ver un ejemplo que siga este enfoque, consulta el tutorial Plantilla flexible para una canalización con dependencias y una imagen de contenedor personalizada.

Usar una imagen de un registro privado

Puedes crear una imagen de plantilla flexible almacenada en un registro de Docker privado si el registro privado usa HTTPS y tiene un certificado válido.

Para usar una imagen de un registro privado, especifica la ruta a la imagen, así como el nombre de usuario y la contraseña del registro. El nombre de usuario y la contraseña deben almacenarse en Secret Manager. Puedes proporcionar el secreto en uno de los siguientes formatos:

projects/{project}/secrets/{secret}/versions/{secret_version}
projects/{project}/secrets/{secret}

Si usas el segundo formato, como no se especifica la versión, Dataflow usa la más reciente.

Si el registro usa un certificado autofirmado, también debe especificar la ruta al certificado autofirmado en Cloud Storage.

En la siguiente tabla se describen las opciones de gcloud CLI que puedes usar para configurar un registro privado.

Parámetro	Descripción
`image`	Dirección del registro. Por ejemplo: `gcp.repository.example.com:9082/registry/example/image:latest`.
`image-repository-username-secret-id`	El ID de secreto de Secret Manager del nombre de usuario para autenticar en el registro privado. Por ejemplo: `projects/example-project/secrets/username-secret`.
`image-repository-password-secret-id`	El ID de secreto de Secret Manager de la contraseña para autenticar en el registro privado. Por ejemplo: `projects/example-project/secrets/password-secret/versions/latest`.
`image-repository-cert-path`	La URL completa de Cloud Storage de un certificado autofirmado para el registro privado. Este valor solo es obligatorio si el registro usa un certificado autofirmado. Por ejemplo: `gs://example-bucket/self-signed.crt`.

Aquí tienes un ejemplo de comando de la CLI de Google Cloud que crea una plantilla flexible usando una imagen de un registro privado con un certificado autofirmado.

gcloud dataflow flex-template build gs://example-bucket/custom-pipeline-private-repo.json
--sdk-language=JAVA
--image="gcp.repository.example.com:9082/registry/example/image:latest"
--image-repository-username-secret-id="projects/example-project/secrets/username-secret"
--image-repository-password-secret-id="projects/example-project/secrets/password-secret/versions/latest"
--image-repository-cert-path="gs://example-bucket/self-signed.crt"
--metadata-file=metadata.json

Para crear tu propia plantilla flexible, debes sustituir los valores de ejemplo y es posible que tengas que especificar otras opciones o añadir más. Para obtener más información, consulta los siguientes recursos:

Especificar las opciones del flujo de procesamiento

Para obtener información sobre las opciones de canalización que admiten directamente las plantillas flexibles, consulta Opciones de canalización.

También puedes usar cualquier opción de canalización de Apache Beam de forma indirecta. Si vas a usar un archivo metadata.json para tu trabajo de plantilla flex, incluye estas opciones de canalización en el archivo. Este archivo de metadatos debe seguir el formato que se indica en TemplateMetadata.

De lo contrario, cuando inicies el trabajo de plantilla Flex, pasa estas opciones de canalización mediante el campo de parámetros.

En el caso de las opciones experimentales de tiempo de ejecución o las opciones de canalización de tiempo de ejecución comunes que no se exponen explícitamente en los metadatos de la plantilla, pasa estas opciones mediante los campos additional-experiments o additional-pipeline-options.

API

Incluye opciones de la canalización con el campo parameters.
Incluye experimentos de tiempo de ejecución y opciones de canalización mediante los campos additionalExperiments y additionalPipelineOptions.

En el siguiente ejemplo se muestra cómo incluir opciones de canalización, experimentos y opciones adicionales en un cuerpo de solicitud:

{
  "jobName": "my-flex-template-job",
  "parameters": {
    "option_defined_in_metadata": "value"
  },
  "environment": {
    "additionalExperiments": [
      "use_runner_v2"
    ],
    "additionalPipelineOptions": {
      "common_pipeline_option": "value"
    }
  }
}

gcloud

Incluye opciones de canalización con la marca parameters.
Incluye experimentos de tiempo de ejecución y opciones de canalización mediante las marcas additional-experiments y additional-pipeline-options.

Cuando se transfieren parámetros de tipo List o Map, es posible que tengas que definir parámetros en un archivo YAML y usar la marca flags-file.

Cuando usas plantillas flexibles, puedes configurar algunas opciones de la canalización durante la inicialización, pero otras no se pueden cambiar. Si se sobrescriben los argumentos de línea de comandos que requiere la plantilla flex, es posible que el trabajo ignore, sobrescriba o descarte las opciones de la canalización que haya pasado el lanzador de plantillas. Es posible que la tarea no se inicie o que se inicie una tarea que no use la plantilla Flex. Para obtener más información, consulta No se ha podido leer el archivo de trabajo.

Durante la inicialización de la canalización, no cambies las siguientes opciones de canalización:

Java

runner
project
jobName
templateLocation
region

Python

runner
project
job_name
template_location
region

Go

runner
project
job_name
template_location
region

Bloquear las claves SSH del proyecto en las VMs que usan claves SSH basadas en metadatos

Puedes impedir que las VMs acepten claves SSH almacenadas en los metadatos del proyecto bloqueando las claves SSH del proyecto en las VMs. Usa la marca additional-experiments con la opción de servicio block_project_ssh_keys:

--additional-experiments=block_project_ssh_keys

Para obtener más información, consulta las opciones de servicio de Dataflow.

Metadatos

Puedes ampliar tu plantilla con metadatos adicionales para que los parámetros personalizados se validen cuando se ejecute la plantilla. Si quieres crear metadatos para tu plantilla, sigue estos pasos:

Crea un archivo metadata.json con los parámetros de Parámetros de metadatos.
Para ver un ejemplo, consulta Archivo de metadatos de ejemplo.
Almacena el archivo de metadatos en Cloud Storage, en la misma carpeta que la plantilla.

Parámetros de metadatos

Clave de parámetro		Obligatorio	Descripción del valor
`name`		Sí	El nombre de la plantilla.
`description`		No	Un breve párrafo de texto que describe la plantilla.
`streaming`		No	Si tiene el valor `true`, esta plantilla admite el streaming. El valor predeterminado es `false`.
`supportsAtLeastOnce`		No	Si `true`, esta plantilla admite el procesamiento al menos una vez. El valor predeterminado es `false`. Asigna el valor `true` a este parámetro si la plantilla se ha diseñado para que funcione con el modo de streaming al menos una vez.
`supportsExactlyOnce`		No	Si `true`, esta plantilla admite el procesamiento una sola vez. El valor predeterminado es `true`.
`defaultStreamingMode`		No	Es el modo de streaming predeterminado para las plantillas que admiten tanto el modo "al menos una vez" como el modo "exactamente una vez". Usa uno de los siguientes valores: `"AT_LEAST_ONCE"`, `"EXACTLY_ONCE"`. Si no se especifica, el modo de transmisión predeterminado es exactamente una vez.
`parameters`		No	Una matriz de parámetros adicionales que usa la plantilla. De forma predeterminada, se usa un array vacío.
	`name`	Sí	El nombre del parámetro que se usa en la plantilla.
	`label`	Sí	Cadena legible por humanos que se usa en la consola para etiquetar el parámetro. Google Cloud
	`helpText`	Sí	Un breve párrafo de texto que describe el parámetro.
	`isOptional`	No	`false` si el parámetro es obligatorio y `true` si es opcional. Si no se le asigna ningún valor, `isOptional` tiene el valor predeterminado `false`. Si no incluye esta clave de parámetro en los metadatos, estos se convertirán en un parámetro obligatorio.
	`regexes`	No	Matriz de expresiones regulares POSIX-egrep en formato de cadena que se usa para validar el valor del parámetro. Por ejemplo, `["^[a-zA-Z][a-zA-Z0-9]+"]` es una única expresión regular que valida que el valor empieza por una letra y, después, tiene uno o más caracteres. Se usa un array vacío de forma predeterminada.

Archivo de metadatos de ejemplo

Java

{
  "name": "Streaming Beam SQL",
  "description": "An Apache Beam streaming pipeline that reads JSON encoded messages from Pub/Sub, uses Beam SQL to transform the message data, and writes the results to a BigQuery",
  "parameters": [
    {
      "name": "inputSubscription",
      "label": "Pub/Sub input subscription.",
      "helpText": "Pub/Sub subscription to read from.",
      "regexes": [
        "[a-zA-Z][-_.~+%a-zA-Z0-9]{2,}"
      ]
    },
    {
      "name": "outputTable",
      "label": "BigQuery output table",
      "helpText": "BigQuery table spec to write to, in the form 'project:dataset.table'.",
      "isOptional": true,
      "regexes": [
        "[^:]+:[^.]+[.].+"
      ]
    }
  ]
}

Python

{
  "name": "Streaming beam Python flex template",
  "description": "Streaming beam example for python flex template.",
  "parameters": [
    {
      "name": "input_subscription",
      "label": "Input PubSub subscription.",
      "helpText": "Name of the input PubSub subscription to consume from.",
      "regexes": [
        "projects/[^/]+/subscriptions/[a-zA-Z][-_.~+%a-zA-Z0-9]{2,}"
      ]
    },
    {
      "name": "output_table",
      "label": "BigQuery output table name.",
      "helpText": "Name of the BigQuery output table name.",
      "isOptional": true,
      "regexes": [
        "([^:]+:)?[^.]+[.].+"
      ]
    }
  ]
}

Puedes descargar archivos de metadatos de las plantillas proporcionadas por Google desde el directorio de plantillas de Dataflow .

Información sobre la ubicación de almacenamiento provisional y la ubicación temporal

Google Cloud CLI ofrece las opciones --staging-location y --temp-location cuando ejecutas una plantilla flexible. Del mismo modo, la API REST de Dataflow proporciona los campos stagingLocation y tempLocation para FlexTemplateRuntimeEnvironment.

En el caso de las plantillas flexibles, la ubicación de almacenamiento es la URL de Cloud Storage en la que se escriben los archivos durante el paso de almacenamiento de la fase de lanzamiento de una plantilla. Dataflow lee estos archivos almacenados para crear el gráfico de la plantilla. La ubicación temporal es la URL de Cloud Storage en la que se escriben los archivos temporales durante el paso de ejecución.

Actualizar una tarea de plantilla Flex

En la siguiente solicitud de ejemplo se muestra cómo actualizar un trabajo de streaming de plantillas mediante el método projects.locations.flexTemplates.launch. Si quieres usar la herramienta de línea de comandos gcloud, consulta Actualizar un flujo de procesamiento.

Si quieres actualizar una plantilla clásica, usa projects.locations.templates.launch en su lugar.

Sigue los pasos para crear una tarea de streaming a partir de una plantilla flexible. Envía la siguiente solicitud HTTP POST con los valores modificados:
```
POST https://dataflow.googleapis.com/v1b3/projects/PROJECT_ID/locations/REGION/flexTemplates:launch
{
    "launchParameter": {
      "update": true
      "jobName": "JOB_NAME",
      "parameters": {
        "input_subscription": "projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME",
        "output_table": "PROJECT_ID:DATASET.TABLE_NAME"
      },
    "containerSpecGcsPath": "STORAGE_PATH"
    },
}
```
- Sustituye PROJECT_ID por el ID del proyecto.
- Sustituye REGION por la región de Dataflow de la tarea que vas a actualizar.
- Sustituye JOB_NAME por el nombre exacto del trabajo que quieras actualizar.
- Asigna parameters a tu lista de pares clave-valor. Los parámetros que se indican son específicos de este ejemplo de plantilla. Si usas una plantilla personalizada, modifica los parámetros según sea necesario. Si utilizas la plantilla de ejemplo, sustituye las siguientes variables.
  - Sustituye SUBSCRIPTION_NAME por el nombre de tu suscripción a Pub/Sub.
  - Sustituye DATASET por el nombre de tu conjunto de datos de BigQuery.
  - Sustituye TABLE_NAME por el nombre de tu tabla de BigQuery.
- Sustituye STORAGE_PATH por la ubicación de Cloud Storage del archivo de plantilla. La ubicación debe empezar por gs://.
Usa el parámetro environment para cambiar la configuración del entorno. Para obtener más información, consulta FlexTemplateRuntimeEnvironment.
Opcional: Para enviar tu solicitud con curl (Linux, macOS o Cloud Shell), guarda la solicitud en un archivo JSON y, a continuación, ejecuta el siguiente comando:
```
curl -X POST -d "@FILE_PATH" -H "Content-Type: application/json" -H "Authorization: Bearer $(gcloud auth print-access-token)"  https://dataflow.googleapis.com/v1b3/projects/PROJECT_ID/locations/REGION/flexTemplates:launch
```
Sustituye FILE_PATH por la ruta al archivo JSON que contiene el cuerpo de la solicitud.
Usa la interfaz de monitorización de flujo de datos para comprobar que se ha creado un nuevo trabajo con el mismo nombre. Este trabajo tiene el estado Actualizado.

Limitaciones

Se aplican las siguientes limitaciones a las tareas de plantillas flexibles:

Debes usar una imagen base proporcionada por Google para empaquetar tus contenedores con Docker. Para ver una lista de las imágenes aplicables, consulta Imágenes base de plantillas Flex.
El programa que crea la canalización debe cerrarse después de llamar a run para que la canalización se inicie.
No se admiten waitUntilFinish (Java) ni wait_until_finish (Python).

Siguientes pasos

Para obtener más información sobre las plantillas clásicas, las plantillas Flex y sus casos prácticos, consulta Plantillas de Dataflow.
Para obtener información sobre cómo solucionar problemas de plantillas Flex, consulta Solucionar problemas de tiempo de espera de plantillas Flex.
Para ver más arquitecturas de referencia, diagramas y prácticas recomendadas, consulta el centro de arquitectura de Cloud.

Configurar plantillas Flex Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Información sobre los permisos de las plantillas Flex

Permisos para crear recursos

Permisos para crear una plantilla Flex

Permisos para ejecutar una plantilla Flex

Definir las variables de entorno obligatorias de Dockerfile

Java

Python

Dependencias de paquetes de Python

Usar un archivo de requisitos y preempaquetar las dependencias con la plantilla

Estructurar la canalización como un paquete y usar paquetes locales

pyproject.toml

setup.py

Dockerfile

Usar un contenedor personalizado que preinstale todas las dependencias

Elige una imagen base

Usar imágenes de contenedor personalizadas

Usar una imagen de un registro privado

Especificar las opciones del flujo de procesamiento

API

gcloud

Java

Python

Go

Bloquear las claves SSH del proyecto en las VMs que usan claves SSH basadas en metadatos

Metadatos

Parámetros de metadatos

Archivo de metadatos de ejemplo

Java

Python

Información sobre la ubicación de almacenamiento provisional y la ubicación temporal

Actualizar una tarea de plantilla Flex

Limitaciones

Siguientes pasos

Configurar plantillas Flex