Guida per sviluppatori Java per Funzioni di Azure

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

Come sviluppatore Java, se non si ha familiarità con Funzioni di Azure, prendere in considerazione la prima lettura di uno degli articoli seguenti:

Introduzione Concetti Scenari/esempi

Nozioni di base sulla funzione 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:

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

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

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

Struttura di cartelle

Ecco la struttura della cartella di un progetto Java 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 inserire più funzioni in un progetto. Evitare di inserire le funzioni in file con estensione jar separati. 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.

Importante

È necessario configurare un account di Archiviazione di Azure nel file local.settings.json per eseguire i trigger di Archivio BLOB di Azure, archiviazione code di Azure o archiviazione tabelle di Azure.

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 corrispondente generato function.json dal plug-in azure-functions-maven-plug-in:

{
  "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 di 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 l'app in locale.

Versioni supportate

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

Versione di Funzioni Versioni Java (Windows) Versioni Java (Linux)
4.x 17
11
8
17
11
8
3.x 11
8
11
8
2.x 8 n/d

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

Specificare la versione di distribuzione

È possibile controllare la versione di Java destinata all'archetipo Maven usando il -DjavaVersion parametro . Il valore di questo parametro può essere 8 o 11.

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

Elemento Valore Java 8 Valore Java 11 Valore Java 17 Descrizione
Java.version 1.8 11 17 Versione di Java usata dal plug-in maven-compilatore.
JavaVersion 8 11 17 Versione Java ospitata dall'app per le funzioni in Azure.

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>

Importante

È necessario disporre della variabile di ambiente JAVA_HOME impostata correttamente sulla directory JDK usata durante la compilazione del codice usando Maven. Assicurarsi che la versione del JDK sia almeno quanto l'impostazione Java.version .

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 per scegliere il os sistema operativo.

Elemento Windows Linux Docker
os windows linux docker

Nell'esempio seguente viene illustrata l'impostazione del sistema operativo nella runtime sezione 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 ), 11 (MSFT) e 17(MSFT). Questi file binari vengono forniti come distribuzione senza costi, multipiattaforma e pronta 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 la 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 Zulu per i file binari di Azure nell'app per le funzioni, configurare di conseguenza l'app. È possibile continuare a usare i file binari Azul per il sito. Tuttavia, tutte le patch di sicurezza o i miglioramenti sono disponibili solo nelle nuove versioni di OpenJDK. A causa di questo, è 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:

Tipo di piano Nome impostazione Commento
Piano a consumo languageWorkers__java__arguments Questa impostazione aumenta i tempi di inizio a freddo per le funzioni Java in esecuzione in un piano di consumo.
Piano Premium
Piano dedicato
JAVA_OPTS

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 .

Portale di Azure

Nella portale di Azure usare la scheda Impostazioni applicazione per aggiungere o l'impostazione languageWorkers__java__argumentsJAVA_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>

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

Associazioni

I binding di input e 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 presenti 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;
    }

Si richiama questa funzione in un HttpRequest oggetto. La funzione scrive più valori nell'archiviazione code.

HttpRequestMessage e HttpResponseMessage

Questi sono definiti in azure-functions-java-library. Sono tipi helper da usare con le funzioni HttpTrigger.

Tipo specializzato Destinazione Uso tipico
HttpRequestMessage<T> Trigger HTTP Metodo Get, intestazioni o query
HttpResponseMessage Associazione di output HTTP Restituisce uno stato diverso da 200

Metadati

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 metadaId:" + metadataId );
        TestData testData = new TestData();
        testData.id = metadataId;
        output.setValue(testData);
    }

Nota

Il nome specificato nell'annotazione deve corrispondere alla proprietà dei metadati.

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 la registrazione di stdout e stderr Java e altre registrazioni delle applicazioni.

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

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

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").

Nell'esempio seguente viene ottenuta 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);
    }
}

Passaggi successivi

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