DataWorks:Desenvolver e implantar extensões: Function Compute

Limitações

• Somente usuários do DataWorks Enterprise Edition podem usar o módulo Extensions.

• O módulo Extensions está disponível nas seguintes regiões: China (Beijing), China (Hangzhou), China (Shanghai), China (Zhangjiakou), China (Shenzhen), China (Chengdu), US (Silicon Valley), US (Virginia), Germany (Frankfurt), Japan (Tokyo), China (Hong Kong) e Singapore.

Observações

• Apenas o Open Platform administrator, o tenant administrator, contas Alibaba Cloud e usuários RAM com a política AliyunDataWorksFullAccess anexada têm permissões de leitura e gravação no backend de desenvolvedor. Para mais informações sobre gerenciamento de permissões, consulte Permission control for global services e RAM policies for service and console permissions.

• Limitações de versão: Se a assinatura do DataWorks Enterprise Edition expirar, todas as extensões ficarão inativas e não poderão mais ser acionadas para verificações de eventos. Verificações já acionadas, mas ainda sem estado final definido, serão aprovadas automaticamente.

• Limitações de nó: Quando um nó composto contendo nós internos, como um Platform for AI node, um do-while node ou um for-each node, aciona uma verificação, todos os nós internos devem ser aprovados antes que as operações subsequentes prossigam.

• Acionamento: Associe várias extensões ao mesmo evento de ponto de extensão. Assim, um único evento pode acionar múltiplas extensões.

• Limitações de eventos: Atualmente, as extensões implantadas via Function Compute suportam pré-eventos para download de dados, pré-eventos para publicação e despublicação de ativos e pré-eventos para upload de dados.

Etapa 1: Configurar dependências da extensão

Ao desenvolver a extensão, adicione as seguintes dependências ao arquivo 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>

Etapa 2: Desenvolver o código da extensão

Para desenvolver uma extensão no Function Compute, implemente o método handleRequest da interface PojoRequestHandler. Esse método recebe objetos ExtensionRequest e o Context, retornando o resultado do processamento por meio da classe ExtensionResponse .

1. Considere os pontos abaixo durante o desenvolvimento do código.

   Analisar o conteúdo da mensagem

   Para obter informações sobre o formato das mensagens de evento enviadas pelo DataWorks, consulte Developer reference: Event list and message format. Nesse formato, o campo messageBody contém o conteúdo específico da mensagem. Durante o desenvolvimento, use o campo messageBody.eventCode para identificar o tipo de mensagem e o campo messageId para obter os detalhes da mensagem.

   Lógica de processamento

   Escreva a lógica de processamento de mensagens conforme seus requisitos de negócio. Os métodos a seguir podem aumentar a eficiência:

   • Use o Advanced feature: Configure parameters for an extension. Por exemplo, use o parâmetro extension.project.disabled para desativar a extensão em um workspace específico.

   • Ao processar pontos de extensão relacionados ao módulo DataStudio, chame a operação GetIDEEventDetail e use o MessageId para obter um snapshot dos dados no momento em que o evento do ponto de extensão foi acionado.

   Nota

   O parâmetro MessageId corresponde ao campo id na mensagem de evento. Para mais informações, consulte Appendix: Format of messages sent from DataWorks to EventBridge.

   Resultado do processamento

   Ao empacotar o resultado ExtensionResponse, especifique um CheckResult. O DataWorks lê o CheckResult final para determinar se o processo falhou.

   • OK: A verificação da extensão foi aprovada para este evento de ponto de extensão.

   • FAIL: A verificação da extensão falhou para este evento de ponto de extensão. Investigue e resolva o erro para garantir que os processos subsequentes sejam executados conforme esperado.

   • WARN: A verificação da extensão foi aprovada para este evento de ponto de extensão, mas um aviso foi gerado.

   Baixe o arquivo de código de exemplo fc_dataworks_demo01-1.0-SNAPSHOT.jar e faça upload dele no Function Compute para validação. O código abaixo fornece mais detalhes:

   Detalhes do código

   App.java

   Implementa a interface PojoRequestHandler e seu método handleRequest para receber objetos ExtensionRequest e o Context, definir a lógica de processamento e retornar o resultado como um objeto ExtensionResponse .

   Este exemplo de código proíbe o upload manual de dados para tabelas 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 a estrutura da requisição para a extensão, encapsulando as mensagens de evento enviadas pelo 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 a estrutura de resposta para a extensão, encapsulando o resultado do processamento.

   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. Após desenvolver o código, empacote o programa em um arquivo .jar ou .zip executável para o Function Compute.

   Abra uma janela de linha de comando no editor de código, navegue até o diretório raiz e execute o comando mvn clean package para empacotar o código.

   • Se a compilação falhar, ajuste o código com base nas mensagens de erro na saída.

   • Se a compilação for bem-sucedida, o arquivo JAR compilado estará localizado no diretório target do projeto. O nome do arquivo segue os campos artifactId e version definidos no arquivo pom.xml, por exemplo, java-example-1.0-SNAPSHOT.jar.

   Nota

   No macOS e Linux, certifique-se de que os arquivos de código tenham permissões de leitura e execução antes do empacotamento.

Etapa 1: Implantar a extensão

1. Faça login no console do Function Compute 2.0 e acesse a página Tasks.

2. Clique em Create Function para criar um service e a função necessária e, em seguida, implante a extensão. Mensagens de eventos específicas da extensão desenvolvida serão enviadas diretamente para este service. Para mais informações, consulte Create a service e Create a function. No painel Create Function, selecione Create with built-in runtimes, escolha Process event requests para o tipo de handler, selecione Upload code via JAR package como método de upload de código e faça upload do pacote de código preparado.

   • Selecione um ambiente de execução compatível com seu código. O pacote de exemplo fornecido na Etapa 1, fc_dataworks_demo01-1.0-SNAPSHOT.jar, corresponde ao ambiente Java 8. Baixe o arquivo fc_dataworks_demo01-1.0-SNAPSHOT.jar para o computador local e faça upload dele como o code package. Configure os demais parâmetros conforme necessário.

   • Para mais informações sobre operações de funções, consulte Manage functions.

3. Modifique o handler da função.

   Configure o handler diretamente no console do Function Compute. Para funções Java, o formato do handler é [Nome do pacote].[Nome da classe]::[Nome do método]. Por exemplo:

   • Nome do pacote: example.

   • Nome da classe: HelloFC.

   • Nome do método: handleRequest.

   O handler pode ser configurado como example.HelloFC::handleRequest.

   Nota

   O handler padrão no Function Compute é example.App::handleRequest. Modifique o handler de acordo com o seu código real. Para mais informações sobre handlers, consulte Handlers.

Etapa 2: Testar a função

Após criar a função, acesse a página de detalhes da função, clique na aba Code e clique em Test Function. Se a mensagem Execution succeeded for retornada, prossiga com o registro da extensão no DataWorks.

Etapa 1: Registrar a extensão

Após implantar a extensão no Function Compute, registre-a no DataWorks.

1. Faça login no console do DataWorks. Na região desejada, clique em More > Open Platform no painel de navegação à esquerda. Clique em Go to Open Platform para abrir a página Developer Backend.

2. Registre a extensão.

   1. No painel de navegação à esquerda, clique em Extensions para acessar a página Extensions.

   2. Clique em List of Extensions > Register Extension, selecione Deploy Based on Function Compute e configure as informações da extensão.

      Configure os parâmetros conforme suas necessidades. A tabela a seguir descreve os parâmetros disponíveis.

   Parâmetros

   Parâmetro	Descrição
   Extension Name	Nome personalizado para identificar a extensão.
   Function Compute Service and Function	Selecione o service e a função do Function Compute para a extensão. As mensagens de evento serão enviadas para este service.
   Processed Extension Points	Somente mensagens acionadas por pré-eventos para download de dados, pré-eventos para publicação e despublicação de ativos e pré-eventos para upload de dados podem ser processadas. Nota Após fazer uma seleção, os campos Event e Applicable Service são preenchidos automaticamente. Não é necessário configurá-los manualmente.
   Owner	Proprietário da extensão, a quem os usuários podem contatar caso encontrem problemas.
   Workspace for Testing	Selecione o workspace para testar a extensão. A extensão será executada neste ambiente de teste sem ser publicada. Antes da publicação, realize testes de ponta a ponta no workspace de teste. Acione um evento para verificar se o DataWorks envia uma mensagem via EventBridge e se a extensão recebe, revisa e fornece um callback para essa mensagem. Nota Se você selecionar um evento de ponto de extensão no nível de tenant em Processed Extension Points, não será necessário configurar o Workspace for Testing.
   Extension Details Address	Insira a URL de uma página que descreva os detalhes da extensão, ajudando os usuários a entendê-la e utilizá-la. Crie uma página de detalhes durante o desenvolvimento e forneça sua URL aqui, permitindo que os usuários visualizem o processo completo de validação quando uma verificação for acionada, incluindo o fluxo de verificação e o motivo de um bloqueio.
   Extension Documentation Address	Insira a URL da documentação de ajuda da extensão. Crie uma página de documentação durante o desenvolvimento e forneça sua URL aqui para ajudar os usuários a compreender a lógica de validação e as propriedades da extensão.
   Parameters for Extension	Use parâmetros para aumentar a eficiência no desenvolvimento e aplicação da extensão. Adicione os parâmetros necessários aqui durante o desenvolvimento do código. Use parâmetros integrados para casos de uso comuns ou defina seus próprios parâmetros. Adicione múltiplos parâmetros, sendo um por linha no formato key=value. Para mais informações sobre como usar parâmetros, consulte Advanced application: Configure extension parameters.
   Options for Extension	Insira as opções de configuração disponíveis para que os usuários personalizem o controle da extensão em diferentes workspaces. Defina essas opções como uma string JSON. Por exemplo, use uma opção para permitir que os usuários controlem o comprimento máximo de SQL. Para o formato JSON, consulte Advanced application: Configure extension options.

3. Conclua o registro.

   Clique em OK. Após concluir o registro, visualize a extensão na List of Extensions.

Etapa 2: Publicar a extensão

Após desenvolver, implantar e registrar a extensão no DataWorks, teste-a, aprove-a e publique-a. Uma vez publicada, administradores que não sejam proprietários da extensão poderão ativá-la no Management Center. Para mais informações, 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.
}