Empaqueter et déployer du code dans un environnement cible pour une exécution correcte et la fourniture de services - Function Compute

Pour déployer une fonction Java sur Function Compute, empaquetez votre code et ses dépendances dans un fichier ZIP ou JAR, puis téléchargez le package via la console Function Compute ou Serverless Devs.

Cette rubrique présente deux méthodes de déploiement :

Déploiement avec Maven — compilez et téléchargez manuellement via la console
Déploiement avec Serverless Devs — compilez et déployez en une seule commande CLI

Bibliothèques de dépendances

Function Compute met à disposition deux bibliothèques Java :

Bibliothèque	Artifact ID	Version	Description
`com.aliyun:fc-java-core`	`fc-java-core`	1.4.1	Définit l'interface du gestionnaire (handler) et l'objet de contexte
`com.aliyun:fc-java-events`	`fc-java-event`	1.2.0	Fournit les types d'événements pour les sources d'événements courantes

Récupérez ces deux bibliothèques depuis le dépôt central Maven, puis ajoutez-les à votre fichier 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>

Si votre package de dépendances est trop volumineux, empaquetez les dépendances dans un layer afin de réduire la taille du package de code. Pour plus d'informations, consultez la rubrique Créer un layer personnalisé .

Déploiement avec Maven

Prérequis

Avant de commencer, assurez-vous d'avoir :

Java installé (site officiel Java)
Maven installé (Installation d'Apache Maven)

Étapes

Créez un projet Java. Placez votre gestionnaire (handler) dans le fichier 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());
    }
}

Pour davantage d'exemples de gestionnaires, consultez les rubriques Gestionnaires et Contexte.

Dans le fichier pom.xml, ajoutez le plugin maven-shade-plugin à la section <build>. Ce plugin regroupe vos dépendances dans un seul fichier JAR adapté au déploiement.

Vous pouvez également utiliser Apache Maven Assembly à la place de 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>Exemple complet de fichier 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>

Depuis le répertoire racine du projet, exécutez la commande suivante :

Important
Sous macOS et Linux, assurez-vous que le fichier de code dispose des droits de lecture et d'exécution avant de le compresser.
```
mvn clean package
```
Une compilation réussie se termine par le message suivant :
```
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.681 s
[INFO] Finished at: 2020-03-26T15:55:05+08:00
[INFO] ------------------------------------------------------------------------
```
Le nom du fichier JAR généré est basé sur les champs artifactId et version définis dans le fichier pom.xml. Dans l'exemple ci-dessus, le fichier est nommé target/HelloFCJava-1.0-SNAPSHOT.jar. En cas d'échec de la compilation, vérifiez le message d'erreur et corrigez le code avant de réessayer.
Connectez-vous à la console Function Compute et téléchargez le fichier JAR.
Sur la page Function Details, accédez à l'onglet Configuration et vérifiez la valeur du champ Handler. Le gestionnaire doit respecter le format [Nom du package].[Nom de la classe]::[Nom de la méthode]. Pour l'exemple ci-dessus, le gestionnaire est example.App::handleRequest. Si nécessaire, cliquez sur Modify dans la section Basic Configurations pour le mettre à jour.
Dans l'onglet Code, cliquez sur Test Function pour vérifier le déploiement.

Déploiement avec Serverless Devs

Serverless Devs gère la compilation et le déploiement en une seule commande : la commande s deploy exécute automatiquement mvn package avant de télécharger votre code.

Prérequis

Avant de commencer, assurez-vous d'avoir :

Serverless Devs et ses dépendances installés. Consultez la rubrique Installer Serverless Devs et les dépendances.
Serverless Devs configuré. Consultez la rubrique Configurer Serverless Devs.
Java Development Kit (JDK) installé. Téléchargez-le depuis la page Java Downloads.
Maven installé. Téléchargez-le depuis la page Apache Maven Downloads.

Étapes

Initialisez un projet :
```
s init
```
Lorsque vous y êtes invité, sélectionnez Alibaba Cloud comme fournisseur, puis choisissez un modèle Java, un runtime, une région et un nom de fonction.

Accédez au répertoire du projet :

cd start-fc-event-java8

La structure du projet se présente comme suit :

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

Déployez le projet :

s deploy

Serverless Devs exécute d'abord la commande mvn package (via le hook pre-deploy), puis télécharge et déploie le fichier JAR. Un déploiement réussi affiche une sortie similaire à celle-ci :

[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

Appelez la fonction pour vérifier son bon fonctionnement :

s invoke

Sortie attendue :

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

Function Compute:Compiler et déployer un package de code

Bibliothèques de dépendances

Déploiement avec Maven

Prérequis

Étapes

Déploiement avec Serverless Devs

Prérequis

Étapes

Étapes suivantes