Todos os produtos
Search

Este produto

    Function Compute:Compile e implante um pacote de código

    Central de documentação

    Function Compute:Compile e implante um pacote de código

    Última atualização: Jun 29, 2026

    Para implantar uma função Java no Function Compute, empacote o código e as dependências em um arquivo ZIP ou JAR e envie o pacote pelo console do Function Compute ou pelo Serverless Devs.

    Este tópico aborda dois caminhos de implantação:

    Bibliotecas de dependência

    O Function Compute oferece duas bibliotecas Java:

    Biblioteca

    Artifact ID

    Versão

    Descrição

    com.aliyun:fc-java-core

    fc-java-core

    1.4.1

    Define a interface do handler e o objeto de contexto

    com.aliyun:fc-java-events

    fc-java-event

    1.2.0

    Fornece tipos de eventos para origens comuns

    Obtenha ambas as bibliotecas no repositório central do Maven e adicione-as ao pom.xml:

    <!-- fc-java-core: required -->
<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-core</artifactId>
    <version>1.4.1</version>
</dependency>

<!-- fc-java-events: optional, add if your function handles events from Alibaba Cloud services -->
<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-event</artifactId>
    <version>1.2.0</version>
</dependency>
    Se o pacote de dependências for muito grande, empacote-as em uma layer para manter o pacote de código pequeno. Para mais detalhes, consulte Criar uma layer personalizada .

    Implantar com Maven

    Pré-requisitos

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

    Etapas

    1. Crie um projeto Java. Coloque o handler em src/main/java/example/App.java:

      package example;

import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.StreamRequestHandler;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class App implements StreamRequestHandler {

    @Override
    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException {
        outputStream.write(new String("hello world").getBytes());
    }
}

      Para mais exemplos de handlers, consulte Handlers e Context.

    2. No pom.xml, adicione o maven-shade-plugin à seção <build>. Esse plugin agrupa as dependências em um único arquivo JAR adequado para implantação.

      Também é possível usar o Apache Maven Assembly em vez do Apache Maven Shade .
      <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>

      <details> <summary>Exemplo completo de pom.xml</summary>

      <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>example</groupId>
  <artifactId>HelloFCJava</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>HelloFCJava</name>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.aliyun.fc.runtime</groupId>
      <artifactId>fc-java-core</artifactId>
      <version>1.4.1</version>
    </dependency>
  </dependencies>

  <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>

  <properties>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.test.skip>true</maven.test.skip>
  </properties>
</project>

      </details>

    3. No diretório raiz do projeto, execute:

      Importante

      No macOS e no Linux, garanta que o arquivo de código tenha permissões de leitura e execução antes de compactá-lo.

      mvn clean package

      Uma compilação bem-sucedida termina com:

      [INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.681 s
[INFO] Finished at: 2020-03-26T15:55:05+08:00
[INFO] ------------------------------------------------------------------------

      O JAR gerado recebe o nome definido nos campos artifactId e version do pom.xml. No exemplo acima, o arquivo é target/HelloFCJava-1.0-SNAPSHOT.jar. Se a compilação falhar, verifique a mensagem de erro e corrija o código antes de tentar novamente.

    4. Acesse o console do Function Compute e envie o arquivo JAR.

      image

    5. Na página Function Details, acesse a aba Configurations e verifique o valor de Handler. O handler deve seguir o formato [Nome do pacote].[Nome da classe]::[Nome do método]. No exemplo acima, o handler é example.App::handleRequest. Clique em Modify para atualizá-lo, se necessário.

      image

    6. Na aba Code, clique em Test Function para validar a implantação.

      image

    Implantar com Serverless Devs

    O Serverless Devs cuida da compilação e da implantação em um único comando: s deploy executa mvn package automaticamente antes de enviar o código.

    Pré-requisitos

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

    Etapas

    1. Inicialize um projeto:

      s init

      Quando solicitado, selecione Alibaba Cloud como provedor e escolha um modelo Java, runtime, região e nome da função.

    2. Acesse o diretório do projeto:

      cd start-fc-event-java8

      A estrutura do projeto é semelhante a esta:

      start-fc-event-java8
├── src
│   └── main
│       └── java
│           └── example
│               └── App.java
├── pom.xml
├── readme
└── s.yaml

    3. Implante o projeto:

      s deploy

      O Serverless Devs executa primeiro o mvn package (hook pre-deploy) e depois envia e implanta o JAR. Uma implantação bem-sucedida termina com uma saída semelhante a:

      [2022-04-07 12:00:09] [INFO] [S-CORE] - Start the pre-action
[2022-04-07 12:00:09] [INFO] [S-CORE] - Action: mvn package
[INFO] Scanning for projects...
[INFO] ------------------------< example:HelloFCJava >-------------------------
[INFO] Building HelloFCJava 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
......
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  3.617 s
[INFO] Finished at: 2022-04-07T20:00:14+08:00
[INFO] ------------------------------------------------------------------------
[2022-04-07 12:00:14] [INFO] [S-CORE] - End the pre-action

 Checking Service, Function (0.64s)
 Creating Service, Function (0.71s)

Tips for next step
======================
* Display information of the deployed resource: s info
* Display metrics: s metrics
* Display logs: s logs
* Invoke remote function: s invoke
* Remove Service: s remove service
* Remove Function: s remove function
* Remove Trigger: s remove trigger
* Remove CustomDomain: s remove domain

helloworld:
  region:   cn-hangzhou
  service:
    name: hello-world-service
  function:
    name:       start-fc-event-java8
    runtime:    java8
    handler:    example.App::handleRequest
    memorySize: 128
    timeout:    60

    4. Invoque a função para verificar se ela executa corretamente:

      s invoke

      Saída esperada:

      ========= FC invoke Logs begin =========
FC Initialize Start RequestId: b246c3bf-06bc-49e5-92b8-xxxxxxxx
FC Initialize End RequestId: b246c3bf-06bc-49e5-92b8-xxxxxxxx
FC Invoke Start RequestId: b246c3bf-06bc-49e5-92b8-xxxxxxxx
FC Invoke End RequestId: b246c3bf-06bc-49e5-92b8-xxxxxxxx

Duration: 7.27 ms, Billed Duration: 8 ms, Memory Size: 128 MB, Max Memory Used: 65.75 MB
========= FC invoke Logs end =========

FC Invoke Result:
hello world

    Próximas etapas