Guida per sviluppatori Java per Funzioni di Azure

Questa guida contiene informazioni dettagliate per facilitare lo sviluppo di Funzioni di Azure con Java.

Per gli sviluppatori Java che non hanno familiarità con Funzioni di Azure, è consigliabile leggere prima uno degli articoli seguenti:

Nozioni di base sulle funzioni Java

Una funzione Java è un metodo public, accompagnato dall'annotazione @FunctionName. Questo metodo definisce la voce per una funzione Java e deve essere unico in un particolare pacchetto. Il pacchetto può avere più classi con più metodi pubblici annotati con @FunctionName. Un singolo pacchetto viene distribuito in un'app per le funzioni in Azure. In Azure l'app per le funzioni fornisce il contesto di distribuzione, esecuzione e gestione per le singole funzioni Java.

Modello di programmazione

I concetti di trigger e binding sono fondamentali in Funzioni di Azure. I trigger avviano l'esecuzione del codice, mentre i binding consentono la trasmissione dei dati e la restituzione dei dati da una funzione, senza dover scrivere codice personalizzato per l'accesso ai dati.

Creare funzioni Java

Per semplificare la creazione di funzioni Java, sono disponibili strumenti e archetipi basati su Maven che usano modelli Java predefiniti che consentono di creare progetti con un trigger di funzione specifico.

Strumenti basati su Maven

Negli ambienti di sviluppo seguenti sono disponibili strumenti di Funzioni di Azure che consentono di creare progetti di funzioni Java:

• Visual Studio Code
• Eclipse
• IntelliJ

Questi articoli illustrano come creare le prime funzioni usando l'IDE preferito.

Eseguire lo scaffold di un progetto

Se si preferisce eseguire lo sviluppo dalla riga di comando dal terminale, il modo più semplice per eseguire lo scaffold dei progetti di funzione basati su Java consiste nell'usare archetipi Apache Maven. L'archetipo Java Maven per Funzioni di Azure è pubblicato con il seguente groupId:artifactId: com.microsoft.azure:azure-functions-archetype.

Il comando seguente genera un nuovo progetto di funzione Java usando questo archetipo:

mvn archetype:generate \
    -DarchetypeGroupId=com.microsoft.azure \
    -DarchetypeArtifactId=azure-functions-archetype

mvn archetype:generate ^
    -DarchetypeGroupId=com.microsoft.azure ^
    -DarchetypeArtifactId=azure-functions-archetype

Per iniziare a usare questo archetipo, vedere Avvio rapido Java.

Struttura delle cartelle

Di seguito è illustrata la struttura di cartelle di un progetto Java di Funzioni di Azure:

FunctionsProject
 | - src
 | | - main
 | | | - java
 | | | | - FunctionApp
 | | | | | - MyFirstFunction.java
 | | | | | - MySecondFunction.java
 | - target
 | | - azure-functions
 | | | - FunctionApp
 | | | | - FunctionApp.jar
 | | | | - host.json
 | | | | - MyFirstFunction
 | | | | | - function.json
 | | | | - MySecondFunction
 | | | | | - function.json
 | | | | - bin
 | | | | - lib
 | - pom.xml

È possibile usare un file host.json per configurare l'app per le funzioni. Ogni funzione ha il proprio file di codice (con estensione java) e il proprio file di configurazione delle associazioni (function.json).

È possibile usare più funzioni in un progetto. Tuttavia, non inserire le funzioni in file JAR separati. L'uso di più file JAR in una singola app per le funzioni non è supportato. L'elemento FunctionApp nella directory di destinazione viene distribuito all'app per le funzioni in Azure.

Trigger e annotazioni

Le funzioni vengono richiamate da un trigger, ad esempio una richiesta HTTP, un timer o un aggiornamento dati. La funzione deve elaborare tale trigger e qualsiasi altro input per generare uno o più output.

Usare le annotazioni Java incluse nel pacchetto com.microsoft.azure.functions.annotation.* per associare input e output ai metodi dell'utente. Per altre informazioni, vedere la documentazione di riferimento per Java.

Esempio:

public class Function {
    public String echo(@HttpTrigger(name = "req", 
      methods = {HttpMethod.POST},  authLevel = AuthorizationLevel.ANONYMOUS) 
        String req, ExecutionContext context) {
        return String.format(req);
    }
}

Ecco il file function.json corrispondente generato da azure-functions-maven-plugin:

{
  "scriptFile": "azure-functions-example.jar",
  "entryPoint": "com.example.Function.echo",
  "bindings": [
    {
      "type": "httpTrigger",
      "name": "req",
      "direction": "in",
      "authLevel": "anonymous",
      "methods": [ "GET","POST" ]
    },
    {
      "type": "http",
      "name": "$return",
      "direction": "out"
    }
  ]
}

Versioni Java

La versione di Java in cui viene eseguita l'app in Azure è specificata nel file pom.xml. L'archetipo Maven genera attualmente un pom.xml per Java 8, che è possibile modificare prima della pubblicazione. La versione Java in pom.xml deve corrispondere alla versione in cui è stata sviluppata e testata localmente l'app.

Versioni supportate

La tabella seguente illustra le versioni java supportate correnti per ogni versione principale del runtime di Funzioni, in base al sistema operativo:

A meno che non si specifichi una versione Java per la distribuzione, per impostazione predefinita l'archetipo Maven è Java 8 durante la distribuzione in Azure.

Specificare la versione di distribuzione

È possibile controllare la versione di Java di destinazione dell'archetipo Maven usando il parametro -DjavaVersion. Il valore di questo parametro può essere 8, 11, 17 o 21.

L'archetipo Maven genera un pom.xml destinato alla versione Java specificata. Gli elementi seguenti in pom.xml indicano la versione java da usare:

Gli esempi seguenti illustrano le impostazioni per Java 8 nelle sezioni pertinenti del file pom.xml:

Java.version

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
    <azure.functions.maven.plugin.version>1.6.0</azure.functions.maven.plugin.version>
    <azure.functions.java.library.version>1.3.1</azure.functions.java.library.version>
    <functionAppName>fabrikam-functions-20200718015742191</functionAppName>
    <stagingDirectory>${project.build.directory}/azure-functions/${functionAppName}</stagingDirectory>
</properties>

JavaVersion

<runtime>
    <!-- runtime os, could be windows, linux or docker-->
    <os>windows</os>
    <javaVersion>8</javaVersion>
    <!-- for docker function, please set the following parameters -->
    <!-- <image>[hub-user/]repo-name[:tag]</image> -->
    <!-- <serverId></serverId> -->
    <!-- <registryUrl></registryUrl>  -->
</runtime>

Specificare il sistema operativo di distribuzione

Maven consente anche di specificare il sistema operativo in cui viene eseguita l'app per le funzioni in Azure. Usare l'elemento os per scegliere il sistema operativo.

L'esempio seguente illustra l'impostazione del sistema operativo nella sezione runtime del file pom.xml:

<runtime>
    <!-- runtime os, could be windows, linux or docker-->
    <os>windows</os>
    <javaVersion>8</javaVersion>
    <!-- for docker function, please set the following parameters -->
    <!-- <image>[hub-user/]repo-name[:tag]</image> -->
    <!-- <serverId></serverId> -->
    <!-- <registryUrl></registryUrl>  -->
</runtime>

Disponibilità del runtime JDK e supporto

Le build Microsoft e Adoptium di OpenJDK sono fornite e supportate in Funzioni per Java 8 (Adoptium), Java 11, 17 e 21 (MSFT). Questi file binari vengono forniti come distribuzione senza costi, multipiattaforma e pronti per la produzione di OpenJDK per Azure. Contengono tutti i componenti necessari per compilare ed eseguire applicazioni Java SE.

Per lo sviluppo o il test locale, è possibile scaricare gratuitamente i file binari della build Microsoft di OpenJDK o Adoptium Temurin. Supporto tecnico di Azure per i problemi con i JDK e le app per le funzioni è disponibile con un piano di supporto completo.

Se si vuole continuare a usare i file binari Zulu per Azure nell'app per le funzioni, configurare l'app di conseguenza. È possibile continuare a usare i file binari Azul per il sito. Tuttavia, eventuali patch o miglioramenti della sicurezza sono disponibili solo nelle nuove versioni di OpenJDK. Per questo motivo, è necessario rimuovere questa configurazione in modo che le app usino la versione più recente disponibile di Java.

Personalizzare JVM

Funzioni di Azure consente di personalizzare la JVM (macchina virtuale Java) usata per eseguire le funzioni Java. Per impostazione predefinita, vengono usate le opzioni JVM seguenti:

• -XX:+TieredCompilation
• -XX:TieredStopAtLevel=1
• -noverify
• -Djava.net.preferIPv4Stack=true
• -jar

È possibile fornire altri argomenti alla JVM usando una delle impostazioni dell'applicazione seguenti, a seconda del tipo di piano:

Le sezioni seguenti illustrano come aggiungere queste impostazioni. Per altre informazioni sull'uso delle impostazioni dell'applicazione, vedere la sezione Usare le impostazioni dell'applicazione.

Azure portal

Nel portale di Azure, usare la scheda Impostazioni applicazione per aggiungere l'impostazione languageWorkers__java__arguments o JAVA_OPTS.

Interfaccia della riga di comando di Azure

È possibile usare il comando az functionapp config appsettings set per aggiungere queste impostazioni, come illustrato nell'esempio seguente per l'opzione -Djava.awt.headless=true:

az functionapp config appsettings set \
    --settings "languageWorkers__java__arguments=-Djava.awt.headless=true" \
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set ^
    --settings "languageWorkers__java__arguments=-Djava.awt.headless=true" ^
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set \
    --settings "JAVA_OPTS=-Djava.awt.headless=true" \
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set ^
    --settings "JAVA_OPTS=-Djava.awt.headless=true" ^
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

Questo esempio abilita la modalità headless. Sostituire anche <APP_NAME> con il nome dell'app per le funzioni e <RESOURCE_GROUP> con il gruppo di risorse.

Librerie di terze parti

Funzioni di Azure supporta l'uso di librerie di terze parti. Per impostazione predefinita, tutte le dipendenze specificate nel file pom.xml del progetto vengono raggruppate automaticamente durante l'obiettivo mvn package. Inserire le librerie non specificate come dipendenze del file pom.xml in una directory lib nella directory radice della funzione. Le dipendenze inserite nella directory lib vengono aggiunte al caricatore di classe di sistema in fase di runtime.

La dipendenza com.microsoft.azure.functions:azure-functions-java-library è specificata in classpath per impostazione predefinita e non deve essere inclusa nella directory lib. Le dipendenze elencate qui, inoltre, vengono aggiunte al classpath da azure-functions-java-worker.

Supporto dei tipi di dati

Per stabilire un'associazione con binding di input/output, è possibile usare oggetti Java precedenti normali (POJO, Plain Old Java Object), tipi definiti in azure-functions-java-library o tipi di dati primitivi, ad esempio stringa o numero intero.

Oggetti POJO

Per la conversione dei dati di input in oggetti POJO, azure-funzioni-java-worker usa la libreria gson. I tipi POJO usati come input delle funzioni devono essere public.

Dati binari

Per associare dati di input/output binari a byte[], impostare il campo dataType nel file function.json su binary:

   @FunctionName("BlobTrigger")
    @StorageAccount("AzureWebJobsStorage")
     public void blobTrigger(
        @BlobTrigger(name = "content", path = "myblob/{fileName}", dataType = "binary") byte[] content,
        @BindingName("fileName") String fileName,
        final ExecutionContext context
    ) {
        context.getLogger().info("Java Blob trigger function processed a blob.\n Name: " + fileName + "\n Size: " + content.length + " Bytes");
    }

Se si prevedono valori null, usare Optional<T>.

Bindings

Le associazioni di input e di output forniscono una modalità dichiarativa per connettersi ai dati dall'interno del codice. Una funzione può avere più binding di input e output.

Esempio di associazione di input

package com.example;

import com.microsoft.azure.functions.annotation.*;

public class Function {
    @FunctionName("echo")
    public static String echo(
        @HttpTrigger(name = "req", methods = { HttpMethod.PUT }, authLevel = AuthorizationLevel.ANONYMOUS, route = "items/{id}") String inputReq,
        @TableInput(name = "item", tableName = "items", partitionKey = "Example", rowKey = "{id}", connection = "AzureWebJobsStorage") TestInputData inputData,
        @TableOutput(name = "myOutputTable", tableName = "Person", connection = "AzureWebJobsStorage") OutputBinding<Person> testOutputData
    ) {
        testOutputData.setValue(new Person(httpbody + "Partition", httpbody + "Row", httpbody + "Name"));
        return "Hello, " + inputReq + " and " + inputData.getKey() + ".";
    }

    public static class TestInputData {
        public String getKey() { return this.rowKey; }
        private String rowKey;
    }
    public static class Person {
        public String partitionKey;
        public String rowKey;
        public String name;

        public Person(String p, String r, String n) {
            this.partitionKey = p;
            this.rowKey = r;
            this.name = n;
        }
    }
}

Questa funzione viene richiamata con una richiesta HTTP.

• Il payload della richiesta HTTP viene passato come String per l'argomento inputReq.
• Viene recuperata una voce dall'archiviazione tabelle e passata come TestInputData all'argomento inputData.

Per ricevere un batch di input, è possibile stabilire un'associazione a String[], POJO[], List<String> o List<POJO>.

@FunctionName("ProcessIotMessages")
    public void processIotMessages(
        @EventHubTrigger(name = "message", eventHubName = "%AzureWebJobsEventHubPath%", connection = "AzureWebJobsEventHubSender", cardinality = Cardinality.MANY) List<TestEventData> messages,
        final ExecutionContext context)
    {
        context.getLogger().info("Java Event Hub trigger received messages. Batch size: " + messages.size());
    }
    
    public class TestEventData {
    public String id;
}

Questa funzione viene attivata ogni volta che sono disponibili nuovi dati nell'hub eventi configurato. Poiché l'oggetto cardinality è impostato su MANY, la funzione riceve un batch di messaggi dall'hub eventi. L'oggetto TestEventData dell'hub eventi viene convertito in EventData per l'esecuzione della funzione.

Esempio di associazione di output

È possibile associare un binding di output al valore restituito usando $return.

package com.example;

import com.microsoft.azure.functions.annotation.*;

public class Function {
    @FunctionName("copy")
    @StorageAccount("AzureWebJobsStorage")
    @BlobOutput(name = "$return", path = "samples-output-java/{name}")
    public static String copy(@BlobTrigger(name = "blob", path = "samples-input-java/{name}") String content) {
        return content;
    }
}

Se sono presenti più associazioni di output, usare il valore restituito per una sola di tali associazioni.

Per inviare più valori di output, usare il tipo OutputBinding<T> definito nel pacchetto azure-functions-java-library.

@FunctionName("QueueOutputPOJOList")
    public HttpResponseMessage QueueOutputPOJOList(@HttpTrigger(name = "req", methods = { HttpMethod.GET,
            HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @QueueOutput(name = "itemsOut", queueName = "test-output-java-pojo", connection = "AzureWebJobsStorage") OutputBinding<List<TestData>> itemsOut, 
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");
       
        String query = request.getQueryParameters().get("queueMessageId");
        String queueMessageId = request.getBody().orElse(query);
        itemsOut.setValue(new ArrayList<TestData>());
        if (queueMessageId != null) {
            TestData testData1 = new TestData();
            testData1.id = "msg1"+queueMessageId;
            TestData testData2 = new TestData();
            testData2.id = "msg2"+queueMessageId;

            itemsOut.getValue().add(testData1);
            itemsOut.getValue().add(testData2);

            return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + queueMessageId).build();
        } else {
            return request.createResponseBuilder(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("Did not find expected items in CosmosDB input list").build();
        }
    }

     public static class TestData {
        public String id;
    }

Questa funzione viene richiamata su un oggetto HttpRequest. La funzione scrive più valori nell'archiviazione code.

HttpRequestMessage e HttpResponseMessage

Questi sono definiti in azure-functions-java-library. Si tratta di tipi di helper che funzionano con le funzioni HttpTrigger.

Metadati UFX

Alcuni trigger inviano metadati dei trigger insieme ai dati di input. È possibile usare l'annotazione @BindingName per stabilire un'associazione con i metadati dei trigger.

package com.example;

import java.util.Optional;
import com.microsoft.azure.functions.annotation.*;


public class Function {
    @FunctionName("metadata")
    public static String metadata(
        @HttpTrigger(name = "req", methods = { HttpMethod.GET, HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) Optional<String> body,
        @BindingName("name") String queryValue
    ) {
        return body.orElse(queryValue);
    }
}

Nell'esempio precedente, queryValue è associato al parametro della stringa di query name nell'URL della richiesta HTTP http://{example.host}/api/metadata?name=test. Di seguito è riportato un altro esempio di binding a Id dai metadati del trigger della coda.

 @FunctionName("QueueTriggerMetadata")
    public void QueueTriggerMetadata(
        @QueueTrigger(name = "message", queueName = "test-input-java-metadata", connection = "AzureWebJobsStorage") String message,@BindingName("Id") String metadataId,
        @QueueOutput(name = "output", queueName = "test-output-java-metadata", connection = "AzureWebJobsStorage") OutputBinding<TestData> output,
        final ExecutionContext context
    ) {
        context.getLogger().info("Java Queue trigger function processed a message: " + message + " with metadataId:" + metadataId );
        TestData testData = new TestData();
        testData.id = metadataId;
        output.setValue(testData);
    }

Contesto di esecuzione

L'oggetto ExecutionContext definito in azure-functions-java-library contiene metodi helper per comunicare con il runtime di Funzioni. Per altre informazioni, vedere l'articolo di riferimento su ExecutionContext.

Logger

Usare l'oggetto getLogger definito in ExecutionContext per scrivere i log dal codice della funzione.

Esempio:

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;

public class Function {
    public String echo(@HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
        if (req.isEmpty()) {
            context.getLogger().warning("Empty request body received by function " + context.getFunctionName() + " with invocation " + context.getInvocationId());
        }
        return String.format(req);
    }
}

Visualizzazione dei log e della traccia

È possibile usare l'interfaccia della riga di comando di Azure per trasmettere in streaming la registrazione dei canali stdout e stderr di Java e per altri Application Logging.

Ecco come configurare l'app per le funzioni per scrivere la registrazione delle applicazioni tramite l'interfaccia della riga di comando di Azure:

az webapp log config --name functionname --resource-group myResourceGroup --application-logging true

az webapp log config --name functionname --resource-group myResourceGroup --application-logging true

Per eseguire lo streaming dell'output dell'app per le funzioni usando l'interfaccia della riga di comando di Azure, aprire un nuovo prompt dei comandi o una sessione terminal o Bash e immettere il comando seguente:

az webapp log tail --name webappname --resource-group myResourceGroup

az webapp log tail --name webappname --resource-group myResourceGroup

Il comando az webapp log tail offre opzioni per filtrare l'output usando l'opzione --provider.

Per scaricare i file di log come un singolo file ZIP usando l'interfaccia della riga di comando di Azure, aprire un nuovo prompt dei comandi o una sessione terminal o Bash e immettere il comando seguente:

az webapp log download --resource-group resourcegroupname --name functionappname

Prima di eseguire questo comando, è necessario aver abilitato la registrazione del file system nel portale di Azure o nell'interfaccia della riga di comando di Azure.

Variabili di ambiente

In Funzioni, le impostazioni dell'app, come le stringhe di connessione al servizio, vengono esposte come variabili di ambiente durante l'esecuzione. È possibile accedere a queste impostazioni usando System.getenv("AzureWebJobsStorage").

L'esempio seguente ottiene l'impostazione applicazione con la chiave denominata myAppSetting:

public class Function {
    public String echo(@HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
        context.getLogger().info("My app setting value: "+ System.getenv("myAppSetting"));
        return String.format(req);
    }
}

Usare l'inserimento delle dipendenze in Funzioni Java

Funzioni di Azure Java supporta lo schema progettuale di software per l'inserimento di dipendenze, una tecnica per ottenere l'IoC (Inversion of Control) tra le classi e le relative dipendenze. Funzioni di Azure Java offre un hook per l'integrazione con i framework di inserimento delle dipendenze più diffusi nelle app per le funzioni. Funzioni di Azure Java SPI contiene un'interfaccia FunctionInstanceInjector. Implementando questa interfaccia, è possibile restituire un'istanza della classe di funzione e le funzioni verranno richiamate in questa istanza. Questo offre a framework come Spring, Quarkus, Google Guice, Dagger, ecc. la possibilità di creare l'istanza della funzione e registrarla nel contenitore IOC. Ciò significa che è possibile usare questi framework di inserimento delle dipendenze per gestire le funzioni in modo naturale.

Injector dell'istanza della funzione per l'inserimento delle dipendenze

azure-function-java-spi contiene un'interfaccia FunctionInstanceInjector

package com.microsoft.azure.functions.spi.inject; 

/** 

 * The instance factory used by DI framework to initialize function instance. 

 * 

 * @since 1.0.0 

 */ 

public interface FunctionInstanceInjector { 

    /** 

     * This method is used by DI framework to initialize the function instance. This method takes in the customer class and returns 

     * an instance create by the DI framework, later customer functions will be invoked on this instance. 

     * @param functionClass the class that contains customer functions 

     * @param <T> customer functions class type 

     * @return the instance that will be invoked on by azure functions java worker 

     * @throws Exception any exception that is thrown by the DI framework during instance creation 

     */ 

    <T> T getInstance(Class<T> functionClass) throws Exception; 

} 

Per altri esempi che usano FunctionInstanceInjector per l'integrazione con i framework di inserimento delle dipendenze, vedere questo repository.

Passaggi successivi

Per altre informazioni sullo sviluppo di Funzioni di Azure in Java, vedere le risorse seguenti:

• Procedure consigliate per Funzioni di Azure
• Guida di riferimento per gli sviluppatori a Funzioni di Azure
• Trigger e associazioni di Funzioni di Azure
• Sviluppo locale ed esecuzione del debug con Visual Studio Code, IntelliJ ed Eclipse
• Debug remoto di funzioni Java usando Visual Studio Code
• Plug-in Maven per Funzioni di Azure
• Semplificare la creazione della funzione tramite l'obiettivo azure-functions:add e preparare una directory di gestione per la distribuzione tramite file ZIP.