Spring Cloud-funktion i Azure

Den här artikeln visar hur du skapar, testar, felsöker och distribuerar en Java Spring Cloud-funktion i Azure Functions. När du är klar körs funktionen i förbrukningsplanen och svarar på HTTP-begäranden.

Förutsättningar

• Ett Azure-abonnemang. Om du inte har en Azure-prenumeration kan du skapa ettkostnadsfritt konto innan du börjar.

Installera följande verktyg för att utveckla funktioner med hjälp av Java:

• Java Developer Kit, version 11
• Apache Maven, version 3.0 eller senare
• Azure CLI
• Azure Functions Core Tools version 4

Vad du ska bygga

Du ska skapa en klassisk "Hello, World"-funktion som körs på Azure Functions och konfigureras med Spring Cloud Function.

Funktionen tar emot ett User JSON-objekt som innehåller ett användarnamn och skickar tillbaka ett Greeting objekt som innehåller välkomstmeddelandet för användaren.

Projektet är tillgängligt i exemplet Spring Cloud Function i Azure i azure-function-java-worker-lagringsplatsen på GitHub. Du kan använda exemplet direkt om du vill se det slutliga arbetet som beskrivs i den här snabbstarten.

Skapa ett nytt Maven-projekt

Skapa ett tomt Maven-projekt och konfigurera det med Spring Cloud Function och Azure Functions.

Skapa en ny pom.xml fil i en tom mapp. Kopiera sedan innehållet från exempelprojektets pom.xml-fil .

Anpassa några egenskaper för ditt program:

• <functionAppName>är namnet på din Azure-funktion.
• <functionAppRegion>är namnet på den Azure region där du distribuerar funktionen.
• <functionResourceGroup>är namnet på den Azure resursgrupp som du använder.

Ändra dessa egenskaper direkt överst i pom.xml-filen, som du ser i följande exempel:

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

Skapa Azure-konfigurationsfiler

Skapa en src/main/resources-mapp och lägg till följande Azure Functions-konfigurationsfiler i den.

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": ""
  }
}

Skapa domänobjekt

Azure Functions kan ta emot och skicka objekt i JSON-format. Skapa User och Greeting objekt som representerar din domänmodell. Du kan skapa mer komplexa objekt med fler egenskaper om du vill anpassa den här snabbstarten.

Skapa en src/main/java/com/example/model-mapp och lägg följande två filer:

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

Skapa Spring Boot-programmet

Det här programmet hanterar all affärslogik och har åtkomst till hela Spring Boot-ekosystemet. Den här funktionen ger dig två huvudsakliga fördelar jämfört med en Azure-standardfunktion:

• Den förlitar sig inte på Azure Functions-API:er, så du kan enkelt portera den till andra system. Du kan till exempel återanvända den i ett vanligt Spring Boot-program.
• Du kan använda alla @Enable anteckningar från Spring Boot för att lägga till nya funktioner.

I src/main/java/com/example-mappen skapar du följande fil som är ett normalt Spring Boot-program:

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

Skapa nu följande fil i mappen src/main/java/com/example/hello . Den här koden innehåller en Spring Boot-komponent som representerar den funktion som du vill köra:

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

Skapa Azure-funktionen

Om du vill använda det fullständiga Azure Functions-API:et skapar du en Azure-funktion som delegerar dess körning till springmolnfunktionen som du skapade i föregående steg.

I mappen src/main/java/com/example/hello skapar du följande Azure Function-klassfil:

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

Den här Java-klassen är en Azure funktion med följande funktioner:

• Klassen har annoteringen @Component, så den är en Spring Bean.
• Namnet på funktionen, som definieras av kommentaren @FunctionName("hello") , är hello.
• Klassen implementerar en riktig Azure-funktion så att du kan använda det fullständiga Azure Functions-API:et här.

Lägg till enhetstester

Det här steget är valfritt men rekommenderas för att verifiera att programmet fungerar korrekt.

Skapa en src/test/java/com/example-mapp och lägg till följande JUnit-tester:

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

Nu kan du testa din Azure-funktion med hjälp av Maven:

mvn clean test

Kör funktionen lokalt

Testa det lokalt innan du distribuerar programmet till Azure Function.

Paketera först programmet i en JAR-fil:

mvn package

Nu när programmet har paketerats kör du det med hjälp azure-functions av Plugin-programmet Maven:

mvn azure-functions:run

Funktionen Azure är nu tillgänglig på din localhost med hjälp av port 7071. Testa funktionen genom att skicka en POST-begäran med ett User objekt i JSON-format. Använd till exempel cURL:

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

Funktionen svarar med ett Greeting objekt i JSON-format:

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

Här är en skärmbild av cURL-begäran överst på skärmen och den lokala Azure-funktionen längst ned:

Felsök funktionen lokalt

I följande avsnitt beskrivs hur du felsöker funktionen.

Felsöka med Intellij IDEA

Öppna projektet i IntelliJ IDEA och skapa sedan en fjärrkonfiguration för JVM-felsökningskörning som ska kopplas. Mer information finns i Självstudie: Fjärrfelsökning.

Kör programmet med följande kommando:

mvn azure-functions:run -DenableDebug

När programmet startar visas följande utdata:

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

Starta projektfelsökning i IntelliJ IDEA. Du ser följande utdata:

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

Markera de brytpunkter som du vill felsöka. IntelliJ IDEA går in i felsökningsläge när en begäran har skickats.

Felsöka med Visual Studio Code

Öppna projektet i Visual Studio Code och konfigurera sedan följande launch.json filinnehåll:

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

Kör programmet med följande kommando:

mvn azure-functions:run -DenableDebug

När programmet startar visas följande utdata:

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

Starta projektfelsökning i Visual Studio Code och markera sedan de brytpunkter som du vill felsöka. Visual Studio Code går in i felsökningsläge när en begäran har skickats. Mer information finns i Köra och felsöka Java.

Distribuera funktionen till Azure Functions

Nu ska du publicera Azure-funktionen till produktion. Kom ihåg att egenskaperna <functionAppName>, <functionAppRegion>och <functionResourceGroup> som du har definierat i filen pom.xml används för att konfigurera funktionen.

Kör Maven för att distribuera din funktion automatiskt:

mvn azure-functions:deploy

Gå nu till Azure Portal för att hitta Function App som har skapats.

Välj funktionen:

• I funktionsöversikten noterar du funktionens URL.
• För att kontrollera din körande funktion, välj Loggströmning i navigeringsmenyn.

Som du gjorde i föregående avsnitt använder du nu cURL för att komma åt funktionen som körs, som du ser i följande exempel. Se till att ersätta your-function-name med ditt riktiga funktionsnamn.

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

Precis som i föregående sektion, ska funktionen svara dig med ett Greeting-objekt, fortfarande i JSON-format:

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

Grattis, du har en Spring Cloud Function som körs på Azure Functions! Mer information och exempel på Spring Cloud-funktioner finns i följande resurser:

• Spring Cloud-funktionsblogg
• Referensdokument för Spring Cloud-funktionen
• Spring Cloud-funktionsexempel

Nästa steg

Om du vill veta mer om Spring och Azure kan du fortsätta till dokumentationscentret för Spring i Azure.