DataWorks:Desarrollo y despliegue de extensiones: Function Compute

Limitaciones

• Solo los usuarios de DataWorks Enterprise Edition pueden utilizar el módulo Extensions.

• El módulo Extensions está disponible en las siguientes regiones: China (Beijing), China (Hangzhou), China (Shanghai), China (Zhangjiakou), China (Shenzhen), China (Chengdu), US (Silicon Valley), US (Virginia), Germany (Frankfurt), Japan (Tokyo), China (Hong Kong), and Singapore.

Notas

• Solo el Open Platform administrator, el tenant administrator, las cuentas de Alibaba Cloud y los usuarios de RAM con la directiva AliyunDataWorksFullAccess adjunta tienen permisos de lectura y escritura en el backend para desarrolladores. Para obtener más información sobre la gestión de permisos, consulte Permission control for global services y RAM policies for service and console permissions.

• Limitaciones de versión: Si la suscripción de DataWorks Enterprise Edition caduca, todas las extensiones quedan inactivas y ya no se activan para verificar eventos. Las verificaciones que se hayan iniciado pero aún no hayan alcanzado un estado final se aprueban automáticamente.

• Limitaciones de nodos: Cuando un nodo compuesto que contiene nodos internos, como un Platform for AI node, un do-while node o un for-each node, activa una verificación, todos los nodos internos deben aprobarla antes de que puedan continuar las operaciones posteriores.

• Activación: Es posible asociar varias extensiones al mismo evento de punto de extensión. Esto significa que un solo evento puede activar múltiples extensiones.

• Limitaciones de eventos: Las extensiones desplegadas mediante Function Compute actualmente admiten pre-eventos para descarga de datos, pre-eventos para publicación y cancelación de publicación de activos, y pre-eventos para carga de datos.

Paso 1: Configurar las dependencias de la extensión

Al desarrollar la extensión, agregue las siguientes dependencias al archivo pom.xml.

<dependency>
 <groupId>com.aliyun</groupId>
 <artifactId>dataworks_public20200518</artifactId>
 <version>5.6.0</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.aliyun.fc.runtime/fc-java-core -->
<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-core</artifactId>
    <version>1.4.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.aliyun.fc.runtime/fc-java-event -->
<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-event</artifactId>
    <version>1.2.0</version>
</dependency>

<build>
        <plugins>
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-shade-plugin</artifactId>
                  <version>3.2.1</version>
                  <executions>
                    <execution>
                      <phase>package</phase>
                      <goals>
                        <goal>shade</goal>
                      </goals>
                      <configuration>
                        <filters>
                          <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                              <exclude>META-INF/*.SF</exclude>
                              <exclude>META-INF/*.DSA</exclude>
                              <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                          </filter>
                        </filters>
                      </configuration>
                    </execution>
                  </executions>
              </plugin>
        </plugins>
</build>

Paso 2: Desarrollar el código de la extensión

Para desarrollar una extensión en Function Compute, implemente el método handleRequest de la interfaz PojoRequestHandler. Este método recibe objetos ExtensionRequest y el Context, y luego devuelve el resultado del procesamiento mediante la clase ExtensionResponse .

1. Tenga en cuenta los siguientes puntos al desarrollar el código.

   Analizar el contenido del mensaje

   Para obtener información sobre el formato de los mensajes de eventos enviados por DataWorks, consulte Developer reference: Event list and message format. En dicho formato, messageBody contiene el contenido específico del mensaje. Durante el desarrollo, utilice el campo messageBody.eventCode para identificar el tipo de mensaje y el campo messageId para obtener los detalles del mensaje.

   Lógica de procesamiento

   Escriba la lógica de procesamiento de mensajes según sus requisitos empresariales. Los siguientes métodos pueden mejorar la eficiencia:

   • Utilice Advanced feature: Configure parameters for an extension. Por ejemplo, use el parámetro extension.project.disabled para deshabilitar la extensión en un espacio de trabajo específico.

   • Al procesar puntos de extensión relacionados con el módulo DataStudio, llame a la operación GetIDEEventDetail y utilice MessageId para obtener una instantánea de los datos del momento en que se activó el evento del punto de extensión.

   Nota

   El parámetro MessageId corresponde al campo id en el mensaje de evento. Para obtener más información, consulte Appendix: Format of messages sent from DataWorks to EventBridge.

   Resultado del procesamiento

   Al empaquetar el resultado ExtensionResponse, especifique un CheckResult. DataWorks lee el CheckResult final para determinar si el proceso falla.

   • OK: La verificación de la extensión se aprobó para este evento de punto de extensión.

   • FAIL: La verificación de la extensión falló para este evento de punto de extensión. Debe investigar y resolver el error para garantizar que los procesos posteriores se ejecuten correctamente.

   • WARN: La verificación de la extensión se aprobó para este evento de punto de extensión, pero se generó una advertencia.

   Descargue el archivo de código de ejemplo fc_dataworks_demo01-1.0-SNAPSHOT.jar y cárguelo en Function Compute para su verificación. El siguiente código proporciona más detalles:

   Detalles del código

   App.java

   Implementa la interfaz PojoRequestHandler y su método handleRequest para recibir objetos ExtensionRequest y el Context, definir la lógica de procesamiento y devolver el resultado como un objeto ExtensionResponse .

   Este ejemplo de código prohíbe la carga manual de datos en tablas ADS.

   package com.aliyun.example;
   import com.alibaba.fastjson.JSON;
   import com.alibaba.fastjson.JSONObject;
   import com.aliyun.dataworks.ExtensionRequest;
   import com.aliyun.dataworks.ExtensionResponse;
   import com.aliyun.fc.runtime.Context;
   import com.aliyun.fc.runtime.PojoRequestHandler;
   public class App implements PojoRequestHandler<ExtensionRequest, ExtensionResponse> {
       public ExtensionResponse handleRequest(ExtensionRequest extensionRequest, Context context) {
           // Print the request content for debugging.
            System.out.println(JSON.toJSONString(extensionRequest));
           // Create a response object.
           ExtensionResponse extensionResponse = new ExtensionResponse();
           // Check if eventType is 'upload-data-to-table'.
           if ("upload-data-to-table".equals(extensionRequest.getEventType())) {
               try {
                   // Convert messageBody to a string and then parse it into a JSONObject.
                   String messageBodyStr = JSON.toJSONString(extensionRequest.getMessageBody());
                   JSONObject messageBody = JSON.parseObject(messageBodyStr);
                   String tableGuid = messageBody.getString("tableGuid");
                   // Check if tableGuid contains 'ads'.
                   if (tableGuid != null && tableGuid.contains("ads")) {
                       extensionResponse.setCheckResult("FAIL");
                   } else {
                       extensionResponse.setCheckResult("OK");
                   }
               } catch (Exception e) {
                   extensionResponse.setCheckResult("FAIL");
                   extensionResponse.setErrorMessage("Error processing request: " + e.getMessage());
                   return extensionResponse;
               }
           } else {
               extensionResponse.setCheckResult("FAIL");
           }
           // Set an error message for feedback.
           extensionResponse.setErrorMessage("This is a test!");
           // Return the response object.
           return extensionResponse;
       }
   }
   

   ExtensionRequest.java

   Define la estructura de solicitud para la extensión y encapsula los mensajes de eventos enviados por DataWorks.

   public class ExtensionRequest {
       private Object messageBody;
       private String messageId;
       private String extensionBizId;
       private String extensionBizName;
       private String eventType;
       private String eventCategoryType;
       private Boolean blockBusiness;
       public ExtensionRequest() {
       }
       public Object getMessageBody() {
           return this.messageBody;
       }
       public void setMessageBody(Object messageBody) {
           this.messageBody = messageBody;
       }
       public String getMessageId() {
           return this.messageId;
       }
       public void setMessageId(String messageId) {
           this.messageId = messageId;
       }
       public String getExtensionBizId() {
           return this.extensionBizId;
       }
       public void setExtensionBizId(String extensionBizId) {
           this.extensionBizId = extensionBizId;
       }
       public String getExtensionBizName() {
           return this.extensionBizName;
       }
       public void setExtensionBizName(String extensionBizName) {
           this.extensionBizName = extensionBizName;
       }
       public String getEventType() {
           return this.eventType;
       }
       public void setEventType(String eventType) {
           this.eventType = eventType;
       }
       public String getEventCategoryType() {
           return this.eventCategoryType;
       }
       public void setEventCategoryType(String eventCategoryType) {
           this.eventCategoryType = eventCategoryType;
       }
       public Boolean getBlockBusiness() {
           return this.blockBusiness;
       }
       public void setBlockBusiness(Boolean blockBusiness) {
           this.blockBusiness = blockBusiness;
       }
   }

   ExtensionResponse.java

   Define la estructura de respuesta para la extensión y encapsula el resultado del procesamiento.

   public class ExtensionResponse {
       private String checkResult;
       private String errorMessage;
       public ExtensionResponse() {
       }
       public String getCheckResult() {
           return this.checkResult;
       }
       public void setCheckResult(String checkResult) {
           this.checkResult = checkResult;
       }
       public String getErrorMessage() {
           return this.errorMessage;
       }
       public void setErrorMessage(String errorMessage) {
           this.errorMessage = errorMessage;
       }
   }

2. Una vez desarrollado el código, empaquete el programa en un archivo .jar o .zip ejecutable para Function Compute.

   Abra una ventana de línea de comandos en su editor de código, vaya al directorio raíz y ejecute el comando mvn clean package para empaquetar el código.

   • If the compilation fails, adjust the code based on the error messages in the output.

   • If the compilation is successful, the compiled JAR file is located in the target directory of the project. The file is named based on the artifactId and version fields in the pom.xml file, for example, java-example-1.0-SNAPSHOT.jar.

   Nota

   En macOS y Linux, asegúrese de que los archivos de código tengan permisos de lectura y ejecución antes de empaquetarlos.

Paso 1: Desplegar la extensión

1. Inicie sesión en la consola de Function Compute 2.0 y vaya a la página Tasks.

2. Haga clic en Create Function para crear un servicio y la función requerida, y luego despliegue la extensión. Los mensajes de eventos específicos de la extensión desarrollada se envían directamente a este servicio. Para obtener más información, consulte Create a service y Create a function. En el panel Create Function, seleccione Create with built-in runtimes, elija Process event requests como tipo de controlador, seleccione Upload code via JAR package como método de carga de código y cargue el paquete de código preparado.

   • Seleccione un entorno de ejecución según su código. El paquete de ejemplo proporcionado en el Paso 1, fc_dataworks_demo01-1.0-SNAPSHOT.jar, corresponde al entorno Java 8. Debe descargar fc_dataworks_demo01-1.0-SNAPSHOT.jar a su computadora local y cargarlo como el code package. Configure otros parámetros según sus necesidades.

   • Para obtener más información sobre las operaciones de funciones, consulte Manage functions.

3. Modifique el controlador de la función.

   El controlador se configura en la consola de Function Compute. Para funciones Java, el formato del controlador es [Package name].[Class name]::[Method name]. Por ejemplo:

   • Nombre del paquete: example.

   • Nombre de la clase: HelloFC.

   • Nombre del método: handleRequest.

   El controlador puede configurarse como example.HelloFC::handleRequest.

   Nota

   El controlador predeterminado en Function Compute es example.App::handleRequest. You must modify the handler based on your actual code. For more information about handlers,; consulte Handlers.

Paso 2: Probar la función

Después de crear la función, vaya a la página de detalles de la función, haga clic en la pestaña Code y luego en Test Function. Si se devuelve el mensaje Execution succeeded, puede proceder a registrar la extensión en DataWorks.

Paso 1: Registrar la extensión

Después de desplegar la extensión en Function Compute, regístrela en DataWorks.

1. Inicie sesión en la consola de DataWorks. En la región objetivo, haga clic en More > Open Platform en el panel de navegación izquierdo. Haga clic en Go to Open Platform para abrir la página Developer Backend.

2. Registre la extensión.

   1. En el panel de navegación izquierdo, haga clic en Extensions para ir a la página Extensions.

   2. Haga clic en List of Extensions > Register Extension, seleccione Deploy Based on Function Compute y configure la información de la extensión.

      Configure los parámetros según sus necesidades. La siguiente tabla describe los parámetros disponibles.

   Parámetros

   Parámetro	Descripción
   Extension Name	Nombre personalizado para identificar la extensión.
   Function Compute Service and Function	Seleccione el servicio y la función de Function Compute para la extensión. Los mensajes de eventos se envían a este servicio.
   Processed Extension Points	Solo se pueden procesar mensajes activados por pre-eventos para descarga de datos, pre-eventos para publicación y cancelación de publicación de activos y pre-eventos para carga de datos. Nota Tras realizar una selección, los campos Event y Applicable Service se completan automáticamente. No es necesario configurarlos manualmente.
   Owner	Propietario de la extensión, a quien los usuarios pueden contactar si encuentran problemas.
   Workspace for Testing	Seleccione el espacio de trabajo para probar la extensión. La extensión se ejecuta en el espacio de trabajo de prueba sin publicarse. Antes de publicar, realice pruebas integrales en el espacio de trabajo de prueba. Active un evento para comprobar que DataWorks envía un mensaje a través de EventBridge y que la extensión lo recibe, lo revisa y proporciona una devolución de llamada. Nota Si selecciona un evento de punto de extensión a nivel de inquilino en Processed Extension Points, no necesita configurar Workspace for Testing.
   Extension Details Address	Introduzca la URL de una página que describa los detalles de la extensión para ayudar a los usuarios a comprenderla y utilizarla. Puede crear una página de detalles durante el desarrollo y proporcionar su URL aquí, permitiendo a los usuarios ver el proceso completo de validación cuando se activa una verificación, como el flujo de verificación y el motivo de un bloqueo.
   Extension Documentation Address	Introduzca la URL de la documentación de ayuda de la extensión. Puede crear una página de documentación durante el desarrollo y proporcionar su URL aquí para ayudar a los usuarios a comprender la lógica de validación y las propiedades de la extensión.
   Parameters for Extension	Utilice parámetros para mejorar la eficiencia del desarrollo y la aplicación de la extensión. Agregue aquí los parámetros necesarios durante el desarrollo del código. Puede usar parámetros integrados para casos de uso comunes o definir los suyos propios. Es posible agregar varios parámetros, con uno por línea en formato key=value. Para obtener más información sobre cómo utilizar parámetros, consulte Advanced application: Configure extension parameters.
   Options for Extension	Introduzca las opciones de configuración disponibles para que los usuarios personalicen el control de la extensión en diferentes espacios de trabajo. Defina estas opciones como una cadena JSON. Por ejemplo, puede usar una opción para permitir que los usuarios controlen la longitud máxima de SQL. Para el formato JSON, consulte Advanced application: Configure extension options.

3. Complete el registro.

   Haga clic en OK. Una vez completado el registro, podrá ver la extensión en List of Extensions.

Paso 2: Publicar la extensión

Después de desarrollar, desplegar y registrar la extensión en DataWorks, debe probarla, aprobarla y publicarla. Una vez publicada, los administradores distintos al propietario de la extensión pueden habilitarla en Management Center. Para obtener más información, consulte Apply an extension.

{
	"blockBusiness": true,
	"eventCategoryType": "resources-download",// The event category.
	"eventType": "upload-data-to-table",// The event type.
	"extensionBizId": "job_6603643923728775070",
	"messageBody": {
             // The message content varies by message type. The following two fields are fixed.
             "tenantId": 28378****10656, // The tenant ID. Each Alibaba Cloud account corresponds to a tenant in DataWorks, and each tenant has a unique ID. You can find this ID in the user information section in the upper-right corner of DataStudio.
             "eventCode": "xxxx"//
	},
	"messageId": "52d44ee7-b51f-4d4d-afeb-*******" // The event ID. This is a unique identifier for the event.
}