Funkcja Spring Cloud na platformie Azure

W tym artykule pokazano, jak kompilować, testować, debugować i wdrażać funkcję Java Spring Cloud w Azure Functions. Po zakończeniu funkcja jest uruchamiana w planie zużycia i odpowiada na żądania HTTP.

Wymagania wstępne

• Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

Aby opracowywać funkcje przy użyciu Java, zainstaluj następujące narzędzia:

• Java Developer Kit, wersja 11
• Apache Maven, wersja 3.0 lub nowsza
• Azure CLI
• Azure Functions Core Tools w wersji 4

Co zbudujesz

Utworzysz klasyczną funkcję "Hello, World", która jest uruchamiana na Azure Functions i jest skonfigurowana przy użyciu funkcji Spring Cloud.

Funkcja odbiera User obiekt JSON, który zawiera nazwę użytkownika i wysyła z powrotem Greeting obiekt zawierający komunikat powitalny dla tego użytkownika.

Projekt jest dostępny w przykładzie funkcji Spring Cloud na platformie Azureazure-function-java-worker w repozytorium w witrynie GitHub. Możesz użyć tego przykładu bezpośrednio, jeśli chcesz zobaczyć ostateczną pracę opisaną w tym przewodniku Szybki start.

Tworzenie nowego projektu Maven

Utwórz pusty projekt Maven i skonfiguruj go za pomocą funkcji Spring Cloud i Azure Functions.

W pustym folderze utwórz nowy plik pom.xml . Następnie skopiuj zawartość z pliku pom.xml przykładowego projektu.

Dostosuj kilka właściwości aplikacji:

• <functionAppName>to nazwa funkcji Azure.
• <functionAppRegion>to nazwa regionu Azure, w którym wdrażasz funkcję.
• <functionResourceGroup>to nazwa używanej grupy zasobów Azure.

Zmień te właściwości bezpośrednio w górnej części pliku pom.xml , jak pokazano w poniższym przykładzie:

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

Tworzenie plików konfiguracji platformy Azure

Utwórz folder src/main/resources i dodaj do niego następujące pliki konfiguracji usługi Azure Functions.

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

Tworzenie obiektów domeny

Usługa Azure Functions może odbierać i wysyłać obiekty w formacie JSON. Utwórz obiekty User i Greeting, które reprezentują Twój model domeny. Jeśli chcesz dostosować ten przewodnik Szybki start, możesz utworzyć bardziej złożone obiekty z większą pulą właściwości.

Utwórz folder src/main/java/com/example/model i dodaj następujące dwa pliki:

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

Tworzenie aplikacji Spring Boot

Ta aplikacja zarządza całą logiką biznesową i ma dostęp do pełnego ekosystemu spring boot. Ta możliwość zapewnia dwie główne korzyści w porównaniu ze standardową funkcją platformy Azure.

• Nie korzysta ona z interfejsów API usługi Azure Functions, więc można łatwo przenosić ją do innych systemów. Można na przykład ponownie użyć jej w normalnej aplikacji Spring Boot.
• Aby dodać nowe funkcje, możesz użyć wszystkich @Enable adnotacji z platformy Spring Boot.

W folderze src/main/java/com/example utwórz następujący plik, który jest zwykłą aplikacją Spring Boot:

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

Teraz utwórz następujący plik w folderze src/main/java/com/example/hello . Ten kod zawiera składnik Spring Boot reprezentujący funkcję, którą chcesz uruchomić:

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

Tworzenie funkcji platformy Azure

Aby użyć pełnego interfejsu API Azure Functions, utwórz funkcję Azure, która deleguje jego wykonywanie do funkcji Spring Cloud utworzonej w poprzednim kroku.

W folderze src/main/java/com/example/hello utwórz następujący plik klasy funkcji platformy Azure:

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

Ta klasa Java jest funkcją Azure z następującymi funkcjami:

• Klasa ma adnotację @Component , więc jest to Spring Bean.
• Nazwa funkcji, zgodnie z definicją adnotacji @FunctionName("hello") , to hello.
• Klasa implementuje rzeczywistą funkcję platformy Azure, dzięki czemu możesz użyć pełnego interfejsu API usługi Azure Functions tutaj.

Dodawanie testów jednostkowych

Ten krok jest opcjonalny, ale zalecany, aby sprawdzić, czy aplikacja działa poprawnie.

Utwórz folder src/test/java/com/example i dodaj następujące testy JUnit:

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

Teraz możesz przetestować funkcję Azure przy użyciu narzędzia Maven:

mvn clean test

Uruchom funkcję lokalnie

Przed wdrożeniem aplikacji w funkcji Azure przetestuj ją lokalnie.

Najpierw spakuj aplikację do pliku JAR:

mvn package

Teraz, gdy aplikacja jest spakowana, uruchom ją przy użyciu azure-functions wtyczki Maven:

mvn azure-functions:run

Funkcja Azure jest teraz dostępna na hoście lokalnym przy użyciu portu 7071. Przetestuj funkcję, wysyłając żądanie POST z obiektem User w formacie JSON. Na przykład użyj biblioteki cURL:

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

Funkcja odpowiada obiektem Greeting w formacie JSON:

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

Oto zrzut ekranu przedstawiający żądanie cURL w górnej części ekranu i lokalną funkcję platformy Azure u dołu:

Lokalne debugowanie funkcji

W poniższych sekcjach opisano sposób debugowania funkcji.

Debugowanie przy użyciu środowiska Intellij IDEA

Otwórz projekt w środowisku IntelliJ IDEA, a następnie utwórz konfigurację uruchamiania zdalnego debugowania JVM w celu dołączenia. Aby uzyskać więcej informacji, zobacz Samouczek: debugowanie zdalne.

Uruchom aplikację za pomocą następującego polecenia:

mvn azure-functions:run -DenableDebug

Po uruchomieniu aplikacji zobaczysz następujące dane wyjściowe:

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

Rozpocznij debugowanie projektu w środowisku IntelliJ IDEA. Zobaczysz następujące dane wyjściowe:

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

Oznacz punkty przerwania, które chcesz debugować. Środowisko IntelliJ IDEA wprowadza tryb debugowania po wysłaniu żądania.

Debugowanie przy użyciu programu Visual Studio Code

Otwórz projekt w Visual Studio Code, a następnie skonfiguruj następującą zawartość pliku launch.json:

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

Uruchom aplikację za pomocą następującego polecenia:

mvn azure-functions:run -DenableDebug

Po uruchomieniu aplikacji zobaczysz następujące dane wyjściowe:

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

Rozpocznij debugowanie projektu w Visual Studio Code, a następnie oznacz punkty przerwania, które chcesz debugować. Visual Studio Code wprowadza tryb debugowania po wysłaniu żądania. Aby uzyskać więcej informacji, zobacz Uruchamianie i debugowanie języka Java.

Wdrażanie funkcji w usłudze Azure Functions

Teraz opublikujesz funkcję platformy Azure w środowisku produkcyjnym. Pamiętaj, że właściwości <functionAppName>, <functionAppRegion> i <functionResourceGroup>, które zdefiniowałeś w pliku pom.xml, są używane do konfigurowania funkcji.

Uruchom narzędzie Maven, aby automatycznie wdrożyć funkcję:

mvn azure-functions:deploy

Teraz przejdź do witryny Azure Portal, aby znaleźć utworzony element Function App.

Wybierz funkcję:

• W omówieniu funkcji zanotuj adres URL funkcji.
• Aby sprawdzić uruchomioną funkcję, wybierz pozycję Rejestrowanie przesyłania strumieniowego w menu nawigacji.

Teraz, podobnie jak w poprzedniej sekcji, użyj narzędzia cURL, aby uzyskać dostęp do uruchomionej funkcji, jak pokazano w poniższym przykładzie. Pamiętaj, aby zastąpić your-function-name rzeczywistą nazwą funkcji.

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

Podobnie jak w poprzedniej sekcji, funkcja powinna odpowiedzieć obiektem Greeting, nadal w formacie JSON:

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

Gratulacje — masz funkcję Spring Cloud działającą w usłudze Azure Functions! Aby uzyskać więcej informacji i przykładów funkcji Spring Cloud, zobacz następujące zasoby:

• Blog funkcji Spring Cloud
• Dokumenty referencyjne funkcji spring cloud
• Przykłady funkcji spring cloud

Następne kroki

Aby dowiedzieć się więcej na temat oprogramowania Spring i platformy Azure, przejdź do centrum dokumentacji dotyczącej oprogramowania Spring na platformie Azure.