Develop custom processors by using Java - Platform For AI: Central de Documentação do Alibaba Cloud

Ciclo de vida do processador

Um processador Java consiste em uma única classe com três fases de ciclo de vida que o EAS chama em sequência:

Fase	Método	Quando é chamado	Obrigatório
Inicializar	Construtor	Uma vez na inicialização do serviço	Sim
Carregar	`Load()`	Uma vez após a construção	Sim
Inferir	`Process(byte[] input)`	Uma vez por requisição recebida	Sim
Testar	`main(String[] args)`	Apenas na máquina local	Não

O EAS executa as fases nesta ordem:

Constructor → Load() → Process() [per request] → ...

Construtor: recebe o caminho do arquivo de modelo (modelEntry) e a string JSON de configuração do serviço (modelConfig) fornecidos durante a implantação.
Load(): carrega o modelo na memória usando os caminhos recebidos pelo construtor.
Process(byte[] input): executa a inferência em cada requisição e retorna o resultado em bytes.

Implemente a classe do processador

Defina uma classe no pacote com.alibaba.eas. O construtor, Load() e Process() são obrigatórios. O método main() é opcional e útil para testes unitários locais sem implantar no EAS.

package com.alibaba.eas;
import java.util.*;

public class TestProcessor {

    // Called once at startup.
    // modelEntry: path to the model file (local or HTTP URL).
    // modelConfig: the service configuration JSON string passed at deploy time.
    public TestProcessor(String modelEntry, String modelConfig) {
    }

    // Load the model into memory. Called once after construction.
    public void Load() {
    }

    // Run inference. Accepts raw bytes; returns raw bytes.
    // Use byte[] instead of String to avoid character encoding issues.
    public byte[] Process(byte[] input) {
    }

    // Optional: test the class locally without deploying to EAS.
    public static void main(String[] args) {
    }
}

Tipos de entrada e saída compatíveis

O método Process() aceita byte[] e String. Prefira byte[] para evitar problemas de codificação de caracteres.

Tratamento de exceções

Se o método Process() lançar uma exceção não capturada, o EAS a interceptará e retornará a mensagem da exceção ao cliente com o código de status HTTP 400.

Para retornar uma mensagem de erro personalizada, capture a exceção dentro de Process() e lance uma RuntimeException com a mensagem desejada para o cliente:

try {
    // inference logic
} catch (com.alibaba.fastjson.JSONException e) {
    throw new RuntimeException("bad json format, " + e.getMessage());
}

Depuração local com modo standalone

O modo standalone permite desenvolver e testar seu processador em uma máquina local sem implantá-lo em um cluster. As interfaces locais são totalmente compatíveis com o ambiente de cluster online, o que possibilita validar o processador antes da implantação.

Nota

O modo standalone requer Docker. Se o seu modelo precisar de GPU, instale também CUDA e Nvidia-Docker na máquina local.

Pré-requisitos

Antes de começar, verifique se você tem:

Docker instalado na máquina onde você executa o EASCMD.
CUDA e Nvidia-Docker instalados (para modelos com GPU).

O cliente EASCMD baixado para o seu sistema operacional:

Plataforma	Link para download
Windows 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdwin64`
Linux 32 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd32`
Linux 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd64`
macOS 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdmac64`

Execute a depuração standalone

Crie um arquivo de configuração de serviço (por exemplo, service.json):

{
  "name": "diy_test",
  "generate_token": "true",
  "model_path": "http://examplebucket.oss-cn-hangzhou-zmf.aliyuncs.com/scorecard.pmml",
  "processor_path": "./diy_processor_release.tar.gz",
  "processor_mainclass": "com.alibaba.eas.TestProcessor",
  "processor_type": "java",
  "metadata": {
    "resource": "eas-r-9lkbl2jvdm0puv****",
    "instance": 1,
    "cpu": 1,
    "memory": 2000
  }
}

Principais parâmetros:

Parâmetro	Descrição
`model_path`	URL HTTP ou caminho local para o arquivo de modelo. Caminhos locais são compatíveis apenas no modo standalone.
`processor_path`	URL HTTP ou caminho local para o pacote do processador. O pacote é um arquivo `.tar.gz` que extrai um arquivo JAR compilado. Caminhos locais são compatíveis apenas no modo standalone.
`processor_mainclass`	Nome totalmente qualificado da classe que implementa `Load()` e `Process()`.
`processor_type`	Defina como `java` para processadores Java.
`metadata.resource`	ID do grupo de recursos dedicado.
`metadata.instance`	Número de instâncias do serviço.
`metadata.cpu`	Quantidade de núcleos de CPU por instância.
`metadata.memory`	Memória por instância, em MB.

Para a referência completa de parâmetros, consulte Execute comandos para usar o cliente EASCMD.

Execute o teste standalone:
```
sudo eascmd test service.json
```