Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Las plantillas de Dataflow te permiten empaquetar una canalización de Dataflow para su implementación.
Cualquier persona con los permisos correctos puede usar la plantilla para implementar la canalización empaquetada.
Puedes crear tus propias plantillas de Dataflow personalizadas y Google proporciona plantillas compiladas con anterioridad para situaciones comunes.
Beneficios
Las plantillas tienen varias ventajas sobre la implementación directa de una canalización en Dataflow:
Las plantillas separan el diseño de canalización de la implementación. Por ejemplo, un desarrollador puede crear una plantilla y un científico de datos puede implementarla más adelante.
Las plantillas pueden tener parámetros que te permitan personalizar la canalización cuando implementas la plantilla.
Puedes implementar una plantilla con la Google Cloud consola, Google Cloud CLI o las llamadas a la API de REST. No necesitas un entorno de desarrollo ni dependencias de canalización instaladas en tu máquina local.
Una plantilla es un artefacto de código que se puede almacenar en un repositorio de control de código fuente y se puede usar en canalizaciones de integración continua (CI/CD).
Plantillas proporcionadas por Google
Google proporciona una variedad de plantillas de Dataflow compiladas de código abierto previamente que puedes usar para situaciones comunes. Para obtener más información sobre las plantillas disponibles, consulta las plantillas que proporciona Google.
Comparación entre las plantillas de Flex y las clásicas
Dataflow admite dos tipos de plantillas: plantillas de Flex, que son más recientes, y plantillas clásicas. Si creas una plantilla de Dataflow nueva, te recomendamos que la crees como plantilla de Flex.
Con una plantilla flexible, la canalización se empaqueta como una imagen de Docker en Artifact Registry, junto con un archivo de especificación de plantilla en Cloud Storage. La especificación de la plantilla contiene un puntero a la imagen de Docker. Cuando ejecutas la plantilla, el servicio de Dataflow inicia una VM de selector, extrae la imagen de Docker y ejecuta la canalización. El grafo de ejecución se compila de forma dinámica según los parámetros del entorno de ejecución que proporciona el usuario. Si deseas usar la API para iniciar un trabajo que use una plantilla de Flex, usa el método projects.locations.flexTemplates.launch.
Una plantilla clásica contiene la serialización de JSON de un grafo de trabajo de Dataflow. El código de la canalización debe unir cualquier parámetro de entorno de ejecución en la interfaz ValueProvider. Esta interfaz permite a los usuarios especificar los valores de los parámetros cuando implementan la plantilla. Si quieres usar la API para trabajar con plantillas clásicas, consulta la documentación de referencia de la API de projects.locations.templates.
Las plantillas de Flex tienen las siguientes ventajas sobre las plantillas clásicas:
A diferencia de las plantillas clásicas, las plantillas de Flex no requieren la interfaz ValueProvider para los parámetros de entrada. No todas las fuentes y receptores de Dataflow admiten ValueProvider.
Si bien las plantillas clásicas tienen un grafo de trabajo estático, las plantillas flexibles pueden construir el grafo de trabajo de forma dinámica. Por ejemplo, la plantilla puede seleccionar un conector de E/S diferente según los parámetros de entrada.
Una plantilla flexible puede realizar un procesamiento previo en una máquina virtual (VM) durante la construcción de la canalización. Por ejemplo, puede validar valores de parámetros de entrada.
Flujo de trabajo de la plantilla
El uso de plantillas de Dataflow implica los siguientes pasos de alto nivel:
Los desarrolladores configuran un entorno de desarrollo y desarrollan su canalización. El entorno incluye el SDK de Apache Beam y otras dependencias.
Según el tipo de plantilla (flexible o clásica), haz lo siguiente:
Para las plantillas flexibles, los desarrolladores empaquetan la canalización en una imagen de Docker, lan envían a Artifact Registry y suben un archivo de especificación de plantilla a Cloud Storage.
Para las plantillas clásicas, los desarrolladores ejecutan la canalización, crean un archivo de plantilla y almacenan la plantilla en Cloud Storage.
Otros usuarios envían una solicitud al servicio de Dataflow para ejecutar la plantilla.
Dataflow crea una canalización a partir de la plantilla. La canalización puede tardar entre cinco y siete minutos en comenzar a ejecutarse.
Configura los permisos de IAM
Los trabajos de Dataflow, incluidos los trabajos que se ejecutan desde plantillas, usan dos cuentas de servicio de IAM:
El servicio de Dataflow usa una cuenta de servicio de Dataflow para manipular recursos de Google Cloud , como la creación de VMs.
Las VM de trabajador de Dataflow usan una cuenta de servicio de trabajador para acceder a los archivos y a otros recursos de la canalización. Esta cuenta de servicio necesita acceder a cualquier recurso al que haga referencia el trabajo de canalización, incluidos el receptor y la fuente que usa la plantilla. Para obtener más información, consulta Accede a los recursos Google Cloud .
Asegúrate de que estas dos cuentas de servicio tengan los roles adecuados. Para obtener más información, consulta Seguridad y permisos de Dataflow.
Requisitos de la versión del SDK de Apache Beam
Para crear tus propias plantillas, asegúrate de que la versión del SDK de Apache Beam admita la creación de plantillas.
Java
Si quieres crear plantillas con el SDK 2.x de Apache Beam para Java, debes tener la versión 2.0.0-beta3 o superior.
Python
Si quieres crear plantillas con el SDK 2.x de Apache Beam para Python, debes tener la versión 2.0.0 o superior.
Para ejecutar plantillas con Google Cloud CLI, debes tener la versión 138.0.0 o posterior de Google Cloud CLI.
Extender plantillas
Puedes compilar tus propias canalizaciones si extiendes las plantillas de Dataflow de código abierto. Por ejemplo, en el caso de una plantilla que usa una duración de ventana fija, los datos que llegan fuera de la ventana podrían descartarse. A fin de evitar este comportamiento, usa el código de la plantilla como base y modifícalo para invocar la operación .withAllowedLateness.
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Información o código de muestra incorrectos","incorrectInformationOrSampleCode","thumb-down"],["Faltan la información o los ejemplos que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-09-04 (UTC)"],[[["\u003cp\u003eDataflow templates allow you to package a Dataflow pipeline for deployment, enabling users with permissions to deploy the packaged pipeline.\u003c/p\u003e\n"],["\u003cp\u003eFlex templates are recommended over classic templates for new Dataflow template creation due to their advantages, such as not requiring the \u003ccode\u003eValueProvider\u003c/code\u003e interface and allowing for dynamic job graph construction.\u003c/p\u003e\n"],["\u003cp\u003eDataflow templates separate pipeline design from deployment, allowing customization through parameters and offering deployment via the Google Cloud console, CLI, or REST API without a development environment.\u003c/p\u003e\n"],["\u003cp\u003eUsing Dataflow templates involves developers packaging the pipeline and other users submitting a request to run it, with Dataflow then creating a pipeline from the template, which can take several minutes to start.\u003c/p\u003e\n"],["\u003cp\u003eDataflow jobs run from templates use two IAM service accounts, a Dataflow service account for manipulating resources and a worker service account for accessing pipeline files and resources.\u003c/p\u003e\n"]]],[],null,["# Dataflow templates allow you to package a Dataflow pipeline for deployment.\nAnyone with the correct permissions can then use the template to deploy the packaged pipeline.\nYou can create your own custom Dataflow templates, and Google provides\n[pre-built templates](/dataflow/docs/templates/provided-templates) for common\nscenarios.\n\nBenefits\n--------\n\nTemplates have several advantages over directly deploying a pipeline to Dataflow:\n\n- Templates separate pipeline design from deployment. For example, a developer can create a template, and a data scientist can deploy the template at a later time.\n- Templates can have parameters that let you customize the pipeline when you deploy the template.\n- You can deploy a template by using the Google Cloud console, the Google Cloud CLI, or REST API calls. You don't need a development environment or any pipeline dependencies installed on your local machine.\n- A template is a code artifact that can be stored in a source control repository and used in continuous integration (CI/CD) pipelines.\n\nGoogle-provided templates\n-------------------------\n\nGoogle provides a variety of pre-built, open source Dataflow templates that you\ncan use for common scenarios. For more information about the available templates, see\n[Google-provided templates](/dataflow/docs/templates/provided-templates).\n\nCompare Flex templates and classic templates\n--------------------------------------------\n\nDataflow supports two types of template: Flex templates, which are newer, and\nclassic templates. If you are creating a new Dataflow template, we recommend\ncreating it as a Flex template.\n\nWith a Flex template, the pipeline is packaged as a Docker image in\nArtifact Registry, along with a template specification file in Cloud Storage. The template\nspecification contains a pointer to the Docker image. When you run the template, the\nDataflow service starts a launcher VM, pulls the Docker image, and runs the\npipeline. The execution graph is dynamically built based on runtime parameters provided by the\nuser. To use the API to launch a job that uses a Flex template, use the\n[`projects.locations.flexTemplates.launch`](/dataflow/docs/reference/rest/v1b3/projects.locations.flexTemplates/launch) method.\n\nA classic template contains the JSON serialization of a Dataflow job graph. The\ncode for the pipeline must wrap any runtime parameters in the `ValueProvider`\ninterface. This interface allows users to specify parameter values when they deploy the\ntemplate. To use the API to work with classic templates, see the\n[`projects.locations.templates`](/dataflow/docs/reference/rest/v1b3/projects.locations.templates)\nAPI reference documentation.\n\nFlex templates have the following advantages over classic templates:\n\n- Unlike classic templates, Flex templates don't require the `ValueProvider` interface for input parameters. Not all Dataflow sources and sinks support `ValueProvider`.\n- While classic templates have a static job graph, Flex templates can dynamically construct the job graph. For example, the template might select a different I/O connector based on input parameters.\n- A Flex template can perform preprocessing on a virtual machine (VM) during pipeline construction. For example, it might validate input parameter values.\n\nTemplate workflow\n-----------------\n\nUsing Dataflow templates involves the following high-level steps:\n\n1. Developers set up a development environment and develop their pipeline. The environment includes the Apache Beam SDK and other dependencies.\n2. Depending on the template type (Flex or classic):\n - For Flex templates, the developers package the pipeline into a Docker image, push the image to Artifact Registry, and upload a template specification file to Cloud Storage.\n - For classic templates, developers run the pipeline, create a template file, and stage the template to Cloud Storage.\n3. Other users submit a request to the Dataflow service to run the template.\n4. Dataflow creates a pipeline from the template. The pipeline can take as much as five to seven minutes to start running.\n\nSet IAM permissions\n-------------------\n\nDataflow jobs, including jobs run from templates, use two IAM service accounts:\n\n- The Dataflow service uses a [Dataflow service account](/dataflow/docs/concepts/security-and-permissions#service_account) to manipulate Google Cloud resources, such as creating VMs.\n- The Dataflow worker VMs use a [worker service account](/dataflow/docs/concepts/security-and-permissions#worker-service-account) to access your pipeline's files and other resources. This service account needs access to any resources that the pipeline job references, including the source and sink that the template uses. For more information, see [Access Google Cloud resources](/dataflow/docs/concepts/security-and-permissions#access-resources).\n\nEnsure that these two service accounts have appropriate roles. For more\ninformation, see\n[Dataflow security and permissions](/dataflow/docs/concepts/security-and-permissions).\n\nApache Beam SDK version requirements\n------------------------------------\n\nTo create your own templates, make sure your Apache Beam SDK version supports template\ncreation. \n\n### Java\n\nTo create templates with the Apache Beam SDK 2.x for Java, you must have version\n2.0.0-beta3 or higher.\n\n### Python\n\nTo create templates with the Apache Beam SDK 2.x for Python, you must have version 2.0.0\nor higher.\n\nTo run templates with Google Cloud CLI, you must have [Google Cloud CLI](/sdk/downloads)\nversion 138.0.0 or higher.\n\nExtend templates\n----------------\n\nYou can build your own templates by extending the\n[open source](https://github.com/GoogleCloudPlatform/DataflowTemplates)\nDataflow templates. For example, for a template that uses a fixed window duration, data\nthat arrives outside of the window might be discarded. To avoid this behavior, use the template\ncode as a base, and modify the code to invoke the\n[`.withAllowedLateness`](https://beam.apache.org/documentation/programming-guide/#managing-late-data) operation.\n\nWhat's next\n-----------\n\n- [Google-provided templates](/dataflow/docs/templates/provided-templates)\n- [Creating classic templates](/dataflow/docs/templates/creating-templates)\n- [Running classic templates](/dataflow/docs/templates/executing-templates)\n- [Build and run Flex Templates](/dataflow/docs/guides/templates/using-flex-templates)\n- [Troubleshoot Flex Templates](/dataflow/docs/guides/troubleshoot-templates)"]]
