Spring Cloud-Funktion in Azure

Artikel
01/22/2025

Dieser Artikel führt Sie durch die Verwendung von Spring Cloud Functions, um eine Java-Funktion zu entwickeln und in Azure Functions zu veröffentlichen. Wenn Sie fertig sind, wird Ihr Funktionscode für den Verbrauchstarif in Azure ausgeführt und kann mithilfe einer HTTP-Anforderung ausgelöst werden.

Voraussetzungen

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

Um Funktionen mit Java zu entwickeln, müssen Sie folgendes installiert haben:

Wichtig

Sie müssen die JAVA_HOME-Umgebungsvariable auf den Installationsspeicherort des JDK festlegen, um diese Schnellstartanleitung abzuschließen.
Stellen Sie sicher, dass Ihre Haupttoolsversion mindestens 4.0.5455 ist.

Was wir bauen werden

Wir werden eine klassische "Hello, World"-Funktion erstellen, die auf Azure-Funktionen 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 an diesen Benutzer enthält.

Das Projekt ist im Spring Cloud Function in Azure-Beispiel des azure-function-java-worker-Repositorys in 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

Wir erstellen ein leeres Maven-Projekt und konfigurieren es mit Spring Cloud Function und Azure Functions.

Erstellen Sie in einem leeren Ordner eine neue pom.xml Datei, und kopieren/einfügen Sie den Inhalt aus der pom.xml-Datei des Beispielprojekts.

Anmerkung

Diese Datei verwendet Maven-Abhängigkeiten von Spring Boot und Spring Cloud Function und konfiguriert die Spring Boot- und Azure Functions Maven-Plug-Ins.

Sie müssen einige Eigenschaften für Ihre Anwendung anpassen:

<functionAppName> ist der Name Ihrer Azure-Funktion.
<functionAppRegion> ist der Name der Azure-Region, in der Ihre Funktion bereitgestellt wird.
<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. Wir erstellen nun unsere User und Greeting Objekte, die unser Domänenmodell darstellen. Sie können komplexere Objekte mit weiteren Eigenschaften erstellen, wenn Sie diese Schnellstartanleitung anpassen und für Sie interessanter machen 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 ausgeführt werden soll:

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");
    }
}

Anmerkung

Die Hello-Funktion ist ziemlich spezifisch:

Es handelt sich um eine java.util.function.Function. Sie enthält die Geschäftslogik und verwendet eine Java-Standard-API, um ein Objekt in ein anderes zu transformieren.
Da sie die Anmerkung @Component aufweist, handelt es sich um einen Spring-Bean, und der Name ist standardmäßig der gleiche wie der der Klasse, jedoch beginnend mit einem Kleinbuchstaben: hello. Das Folgen dieser Benennungskonvention ist wichtig, wenn Sie andere Funktionen in Ihrer Anwendung erstellen möchten. Der Name muss mit dem Namen der Azure-Funktionen übereinstimmen, den wir im nächsten Abschnitt erstellen.

Erstellen der Azure-Funktion

Um von der vollständigen Azure Functions-API zu profitieren, codieren wir nun eine Azure-Funktion, die ihre Ausführung an die Spring Cloud Function delegiert, die im vorherigen Schritt erstellt wurde.

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-Funktion mit den folgenden interessanten 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 Jetzt Ihre Azure-Funktion mit Maven testen:

mvn clean test

Lokales Ausführen der Funktion

Bevor Sie Ihre Anwendung in Azure Function bereitstellen, testen wir sie zuerst lokal.

Zuerst müssen Sie Ihre Anwendung in eine Jar-Datei verpacken:

mvn package

Nachdem die Anwendung gepackt wurde, können Sie sie mit dem azure-functions Maven-Plug-In ausführen:

mvn azure-functions:run

Die Azure-Funktion sollte jetzt auf Ihrem localhost mit Port 7071 verfügbar sein. Sie können die Funktion testen, indem Sie eine POST-Anforderung senden, die ein User-Objekt im JSON-Format enthält. Verwenden Sie beispielsweise cURL:

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

Die Funktion sollte Sie mit einem Greeting-Objekt beantworten, das sich weiterhin im JSON-Format befindet:

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

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

Azure-Funktion, die lokal 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 eine Laufzeitkonfiguration vom Typ Remote JVM Debug, die angefügt werden kann. Weitere Informationen finden Sie im Tutorial: Remote-Debug.

Erstellen einer Remote-JVM-Debugausführungskonfiguration

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. Die 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 Debuggen des Projekts in Visual Studio Code, und markieren Sie die gewünschten Breakpoints für das Debuggen. 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.

Anmerkung

Das Maven-Plug-In muss sich bei Azure authentifizieren. Wenn Sie Azure CLI installiert haben, verwenden Sie az login, bevor Sie fortfahren. Weitere Authentifizierungsoptionen finden Sie unter Authentifizierung im Repository azure-maven-plugins.

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:

Nächste Schritte

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

Spring in Azure

Freigeben über

Spring Cloud-Funktion in Azure

Voraussetzungen

Was wir bauen werden

Erstellen eines neuen Maven-Projekts

Erstellen von Azure-Konfigurationsdateien

Erstellen von Domänenobjekten

Erstellen der Spring Boot-Anwendung

Erstellen der Azure-Funktion

Komponententests hinzufügen

Lokales Ausführen der Funktion

Lokales Debuggen der Funktion

Debuggen mit Intellij IDEA

Debuggen mit Visual Studio Code

Funktion in Azure Functions bereitstellen

Nächste Schritte

Feedback

Zusätzliche Ressourcen