Spring Cloud-Funktion in Azure

In diesem Artikel erfahren Sie, wie Sie eine Java Spring Cloud Function in Azure Functions erstellen, testen, debuggen und bereitstellen. Wenn Sie fertig sind, wird Ihre Funktion im Verbrauchsplan ausgeführt und antwortet auf HTTP-Anforderungen.

Voraussetzungen

• Ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.

Um Funktionen mithilfe von Java zu entwickeln, installieren Sie die folgenden Tools:

• Java Developer Kit, Version 11
• Apache Maven, Version 3.0 oder höher
• Azure-Befehlszeilenschnittstelle
• Azure Functions Core Tools Version 4

Was Sie erstellen möchten

Sie erstellen eine klassische "Hello, World"-Funktion, die auf Azure Functions ausgeführt wird und mit Spring Cloud Function konfiguriert ist.

Die Funktion empfängt ein User JSON-Objekt, das einen Benutzernamen enthält, und sendet ein Greeting Objekt zurück, das die Willkommensnachricht für diesen Benutzer enthält.

Das Projekt ist im Spring Cloud Function in Azure-Beispiel des azure-function-java-worker Repository auf GitHub verfügbar. Sie können dieses Beispiel direkt verwenden, wenn Sie sich das Endprodukt ansehen möchten, das in dieser Schnellstartanleitung beschrieben wird.

Erstellen eines neuen Maven-Projekts

Erstellen Sie ein leeres Maven-Projekt, und konfigurieren Sie es mit Spring Cloud Function und Azure Functions.

Erstellen Sie in einem leeren Ordner eine neue pom.xml Datei. Kopieren Sie dann den Inhalt aus der pom.xml-Datei des Beispielprojekts.

Passen Sie einige Eigenschaften für Ihre Anwendung an:

• <functionAppName>ist der Name ihrer Azure-Funktion.
• <functionAppRegion>ist der Name des Azure Bereichs, in dem Sie Ihre Funktion bereitstellen.
• <functionResourceGroup>ist der Name der Azure Ressourcengruppe, die Sie verwenden.

Ändern Sie diese Eigenschaften direkt am Anfang der pom.xml Datei, wie im folgenden Beispiel gezeigt:

    <properties>
        <java.version>11</java.version>

        <!-- Spring Boot start class. WARNING: correct class must be set -->
        <start-class>com.example.DemoApplication</start-class>

        <!-- customize those properties. WARNING: the functionAppName should be unique across Azure -->
        <azure.functions.maven.plugin.version>1.36.0</azure.functions.maven.plugin.version>
        <functionResourceGroup>my-spring-function-resource-group</functionResourceGroup>
        <functionAppServicePlanName>my-spring-function-service-plan</functionAppServicePlanName>
        <functionAppName>my-spring-function</functionAppName>
        <functionPricingTier>Y1</functionPricingTier>
        <functionAppRegion>eastus</functionAppRegion>
    </properties>

Erstellen von Azure-Konfigurationsdateien

Erstellen Sie einen src/main/resources Ordner; und fügen Sie die folgenden Azure Functions-Konfigurationsdateien hinzu.

host.json:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.2.0)"
  },
  "functionTimeout": "00:10:00"
}

local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "FUNCTIONS_EXTENSION_VERSION": "~4",
    "AzureWebJobsDashboard": ""
  }
}

Erstellen von Domänenobjekten

Azure Functions kann Objekte im JSON-Format empfangen und senden. Erstellen User und Greeting Objekte, die Ihr Domänenmodell darstellen. Sie können komplexere Objekte mit weiteren Eigenschaften erstellen, wenn Sie diese Schnellstartanleitung anpassen möchten.

Erstellen Sie einen src/main/java/com/example/model Ordner, und fügen Sie die folgenden beiden Dateien hinzu:

User.java:

package com.example.model;

public class User {

    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Greeting.java:

package com.example.model;

public class Greeting {

    private String message;

    public Greeting() {
    }

    public Greeting(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Erstellen der Spring Boot-Anwendung

Diese Anwendung verwaltet alle Geschäftslogik und hat Zugriff auf das vollständige Spring Boot-Ökosystem. Diese Funktion bietet Ihnen zwei Hauptvorteile gegenüber einer Standardmäßigen Azure-Funktion:

• Es basiert nicht auf den Azure Functions-APIs, sodass Sie sie problemlos zu anderen Systemen portieren können. Sie können sie beispielsweise in einer normalen Spring Boot-Anwendung wiederverwenden.
• Sie können alle @Enable-Annotations aus Spring Boot verwenden, um neue Funktionen hinzuzufügen.

Erstellen Sie im src/main/java/com/example Ordner die folgende Datei, bei der es sich um eine normale Spring Boot-Anwendung handelt:

DemoApplication.java:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Erstellen Sie nun die folgende Datei im Ordner src/main/java/com/example/hello. Dieser Code enthält eine Spring Boot-Komponente, die die Funktion darstellt, die Sie ausführen möchten:

Hello.java:

package com.example.hello;

import com.example.model.*;
import org.springframework.stereotype.Component;
import java.util.function.Function;

@Component
public class Hello implements Function<User, Greeting> {

    @Override
    public Greeting apply(User user) {
        return new Greeting("Hello, " + user.getName() + "!\n");
    }
}

Erstellen der Azure-Funktion

Um die vollständige Azure Functions-API zu verwenden, erstellen Sie eine Azure-Funktion, die die Ausführung an die Spring Cloud Function delegiert, die Sie im vorherigen Schritt erstellt haben.

Erstellen Sie im Ordner src/main/java/com/example/hello die folgende Azure Function-Klassendatei:

HelloHandler.java:

package com.example.hello;

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.example.model.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Optional;

@Component
public class HelloHandler {

    @Autowired
    private Hello hello;

    @FunctionName("hello")
    public HttpResponseMessage execute(
        @HttpTrigger(name = "request", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<User>> request, ExecutionContext context) {
        User user = request.getBody()
                           .filter(u -> u.getName() != null)
                           .orElseGet(() -> new User(request.getQueryParameters().getOrDefault("name", "world")));
        context.getLogger().info("Greeting user name: " + user.getName());
        return request.createResponseBuilder(HttpStatus.OK)
                      .body(hello.apply(user))
                      .header("Content-Type", "application/json")
                      .build();
    }
}

Diese Java Klasse ist eine Azure Function mit den folgenden Features:

• Die Klasse hat die @Component-Anmerkung, sodass es sich um eine Spring-Bean-Klasse handeln kann.
• Der Name der Funktion, wie durch die @FunctionName("hello")-Annotation definiert, ist hello.
• Die Klasse implementiert eine echte Azure-Funktion, sodass Sie hier die vollständige Azure Functions-API verwenden können.

Komponententests hinzufügen

Dieser Schritt ist optional, wird jedoch empfohlen, zu überprüfen, ob die Anwendung ordnungsgemäß funktioniert.

Erstellen Sie einen src/test/java/com/example Ordner, und fügen Sie die folgenden JUnit-Tests hinzu:

HelloTest.java:

package com.example;

import com.example.hello.Hello;
import com.example.model.Greeting;
import com.example.model.User;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class HelloTest {

    @Test
    public void test() {
        Greeting result = new Hello().apply(new User("foo"));
        assertThat(result.getMessage()).isEqualTo("Hello, foo!\n");
    }
}

Sie können ihre Azure-Funktion jetzt mit Maven testen:

mvn clean test

Lokales Ausführen der Funktion

Bevor Sie Ihre Anwendung für Azure-Funktion bereitstellen, testen Sie sie lokal.

Packen Sie zunächst Ihre Anwendung in eine JAR-Datei:

mvn package

Nachdem die Anwendung gepackt wurde, führen Sie sie mit dem azure-functions Maven-Plug-In aus:

mvn azure-functions:run

Die Azure-Funktion ist jetzt auf Ihrem localhost mit Port 7071 verfügbar.The Azure Function is now available on your localhost, using port 7071. Testen Sie die Funktion, indem Sie sie eine POST-Anforderung mit einem User Objekt im JSON-Format senden. Verwenden Sie z. B. cURL:

curl -X POST http://localhost:7071/api/hello -d "{\"name\":\"Azure\"}"

Die Funktion antwortet mit einem Greeting Objekt im JSON-Format:

{
  "message": "Hello, Azure!\n"
}

Hier sehen Sie einen Screenshot der cURL-Anforderung oben auf dem Bildschirm und die lokale Azure-Funktion unten:

ausgeführt wird

Lokales Debuggen der Funktion

In den folgenden Abschnitten wird beschrieben, wie die Funktion gedebuggt wird.

Debuggen mit Intellij IDEA

Öffnen Sie das Projekt in IntelliJ IDEA, und erstellen Sie dann eine Remote-JVM-Debugausführungskonfiguration zum Anfügen. Weitere Informationen finden Sie im Tutorial: Remote-Debug.

Führen Sie die Anwendung mit dem folgenden Befehl aus:

mvn azure-functions:run -DenableDebug

Wenn die Anwendung gestartet wird, wird die folgende Ausgabe angezeigt:

Worker process started and initialized.
Listening for transport dt_socket at address: 5005

Starten Sie das Projektdebugging in IntelliJ IDEA. Die folgende Ausgabe wird angezeigt:

Connected to the target VM, address: 'localhost:5005', transport: 'socket'

Markieren Sie die gewünschten Breakpoints für das Debuggen. IntelliJ IDEA wechselt nach dem Senden einer Anforderung in den Debugmodus.

Debuggen mit Visual Studio Code

Öffnen Sie das Projekt in Visual Studio Code, und konfigurieren Sie dann den folgenden launch.json Dateiinhalt:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Attach to Remote Program",
            "request": "attach",
            "hostName": "127.0.0.1",
            "port": 5005
        }
    ]
}

Führen Sie die Anwendung mit dem folgenden Befehl aus:

mvn azure-functions:run -DenableDebug

Wenn die Anwendung gestartet wird, wird die folgende Ausgabe angezeigt:

Worker process started and initialized.
Listening for transport dt_socket at address: 5005

Starten Sie das Projektdebugging in Visual Studio Code, und markieren Sie dann die Haltepunkte, die Sie debuggen möchten. Visual Studio Code wechselt nach dem Senden einer Anforderung in den Debugmodus. Weitere Informationen finden Sie unter Ausführen und Debuggen von Java-.

Funktion in Azure Functions bereitstellen

Jetzt veröffentlichen Sie die Azure-Funktion in die Produktionsumgebung. Denken Sie daran, dass die eigenschaften <functionAppName>, <functionAppRegion>und <functionResourceGroup>, die Sie in Der datei pom.xml definiert haben, zum Konfigurieren Ihrer Funktion verwendet werden.

Führen Sie Maven aus, um Ihre Funktion automatisch bereitzustellen:

mvn azure-functions:deploy

Wechseln Sie nun zum Azure-Portal, um die Function App zu suchen, die erstellt wurde.

Wählen Sie die Funktion aus:

• Beachten Sie in der Funktionsübersicht die URL der Funktion.
• Um die ausgeführte Funktion zu überprüfen, wählen Sie Protokollstreaming im Navigationsmenü aus.

Verwenden Sie nun wie im vorherigen Abschnitt cURL, um auf die ausgeführte Funktion zuzugreifen, wie im folgenden Beispiel gezeigt. Achten Sie darauf, your-function-name durch ihren tatsächlichen Funktionsnamen zu ersetzen.

curl https://your-function-name.azurewebsites.net/api/hello -d "{\"name\":\"Azure\"}"

Die Funktion sollte Ihnen wie im vorherigen Abschnitt mit einem Greeting-Objekt antworten, immer noch im JSON-Format:

{
  "message": "Hello, Azure!\n"
}

Herzlichen Glückwunsch, Sie haben eine Spring Cloud-Funktion, die auf Azure Functions ausgeführt wird! Weitere Informationen und Beispiele für Spring Cloud-Funktionen finden Sie in den folgenden Ressourcen:

• Blog der Spring Cloud Function
• Spring Cloud-Funktionsreferenzdokumente
• Spring Cloud Function-Beispiele

Nächste Schritte

Um mehr über Spring und Azure zu erfahren, fahren Sie mit dem Spring on Azure-Dokumentationscenter fort.