Spring Cloud-függvény az Azure-ban

  • Cikk

Ez a cikk végigvezeti a Spring Cloud-függvények használatán, amelyekkel Java-függvényeket hozhat létre, majd közzéteheti őket az Azure Functions szolgáltatásban. Ha elkészült, a függvény kódja az Azure-beli használatalapú csomagban fut, és HTTP-kérelemmel aktiválható.

Ha nem rendelkezik Azure-előfizetéssel, első lépésként mindössze néhány perc alatt létrehozhat egy ingyenes fiókot.

Előfeltételek

Ha függvényeket szeretne fejleszteni a Java használatával, akkor a számítógépre a következőket kell telepíteni:

Fontos

  1. A rövid útmutató elvégzéséhez a JAVA_HOME környezeti változót a JDK telepítési helyére kell állítania.
  2. Győződjön meg arról, hogy az alapvető eszközök verziója legalább 4.0.5455.

Mit fogunk felépíteni?

Létrehozunk egy klasszikus "Hello, World" függvényt, amely az Azure Functionsben fut, és a Spring Cloud-függvénysel van konfigurálva.

A függvény kap egy User JSON-objektumot, amely egy felhasználónevet tartalmaz, és visszaküld egy Greeting objektumot, amely tartalmazza az üdvözlő üzenetet az adott felhasználónak.

A projekt a Spring Cloud-függvényben érhető el a GitHub azure-function-java-worker adattárának Azure-mintájában. Ezt a mintát közvetlenül is használhatja, ha meg szeretné tekinteni az ebben a rövid útmutatóban leírt végső munkát.

Új Maven-projekt létrehozása

Létrehozunk egy üres Maven-projektet, és konfiguráljuk a Spring Cloud Functions és az Azure Functions használatával.

Egy üres mappában hozzon létre egy új pom.xml fájlt, és másolja/illessze be a tartalmat a mintaprojekt pom.xml fájljából.

Megjegyzés:

Ez a fájl mind a Spring Boot, mind a Spring Cloud-függvény Maven-függőségeit használja, és a Spring Boot és az Azure Functions Maven-bővítményeit konfigurálja.

Testre kell szabnia néhány tulajdonságot az alkalmazáshoz:

  • <functionAppName> az Azure-függvény neve
  • <functionAppRegion> annak az Azure-régiónak a neve, ahol a függvény üzembe van helyezve
  • <functionResourceGroup> a használt Azure-erőforráscsoport neve

Módosítsa ezeket a tulajdonságokat közvetlenül a pom.xml fájl tetején, ahogy az a következő példában látható:

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

Azure-beli konfigurációs fájlok létrehozása

Hozzon létre egy src/main/resources mappát, és adja hozzá az alábbi Azure Functions-konfigurációs fájlokat.

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

Tartományi objektumok létrehozása

Az Azure Functions JSON formátumban fogadhat és küldhet objektumokat. Most létrehozzuk a saját és Greeting az objektumainkatUser, amelyek a tartománymodellt képviselik. Ha személyre szabott útmutatót szeretne, és érdekesebbé szeretné tenni az élményt, összetettebb objektumokat is létrehozhat, amelyek több tulajdonsággal rendelkeznek.

Hozzon létre egy src/main/java/com/example/model mappát, majd adja hozzá a következő két fájlt:

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

A Spring Boot-alkalmazás létrehozása

Ez az alkalmazás minden üzleti logikát kezel, és hozzáféréssel rendelkezik a teljes Spring Boot-ökoszisztémához. Ez a funkció két fő előnyt biztosít egy standard Azure-függvény esetében:

  • Nem támaszkodik az Azure Functions API-kra, így könnyen átkötheti más rendszerekbe. Használhatja például egy normál Spring Boot-alkalmazásban.
  • A Spring Boot összes @Enable megjegyzésével új funkciókat vehet fel.

Az src/main/java/com/example mappában hozza létre a következő fájlt, amely egy normál Spring Boot-alkalmazás:

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

Most hozza létre a következő fájlt az src/main/java/com/example/hello mappában. Ez a kód egy Spring Boot-összetevőt tartalmaz, amely a futtatni kívánt függvényt jelöli:

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

Megjegyzés:

A Hello függvény igen konkrét:

  • Ez egy java.util.function.Function. Tartalmazza az üzleti logikát, és egy szabványos Java API-t használ az egyik objektum egy másikká alakításához.
  • Mivel rendelkezik a @Component széljegyzetgel, ez egy Spring Bean, és alapértelmezés szerint a neve megegyezik az osztályéval, de kisbetűvel kezdődik: hello. Az elnevezési konvenció követése akkor fontos, ha más függvényeket szeretne létrehozni az alkalmazásban. A névnek meg kell egyeznie a következő szakaszban létrehozott Azure Functions-névvel.

Az Azure-függvény létrehozása

A teljes Azure Functions API előnyeinek kihasználásához most egy Azure-függvényt kódzünk, amely delegálja annak végrehajtását az előző lépésben létrehozott Spring Cloud-függvényre.

Az src/main/java/com/example/hello mappában hozza létre a következő Azure-függvényosztályfájlt:

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

Ez a Java-osztály egy Azure-függvény, amely a következő érdekes funkciókkal rendelkezik:

  • Az osztály rendelkezik a @Component széljegyzetekkel, szóval ez egy Spring Bean.
  • A függvény neve a széljegyzet által @FunctionName("hello") definiált.hello
  • Az osztály valós Azure-függvényt implementál, így itt használhatja a teljes Azure Functions API-t.

Egységtesztek hozzáadása

Ez a lépés nem kötelező, de ajánlott ellenőrizni, hogy az alkalmazás megfelelően működik-e.

Hozzon létre egy src/test/java/com/example mappát, és adja hozzá a következő JUnit-teszteket:

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

Most már tesztelheti az Azure-függvényt a Mavennel:

mvn clean test

A függvény helyi futtatása

Mielőtt üzembe helyezné az alkalmazást az Azure-függvényben, először tesztelje azt helyileg.

Elsőként egy Jar-fájlba kell csomagolni az alkalmazást:

mvn package

Az alkalmazás becsomagolása után az azure-functions Mavenbeli beépülő modullal futtathatja:

mvn azure-functions:run

Az Azure-függvénynek mostantól elérhetőnek kell lennie a localhoston, a 7071-es porton keresztül. A függvény teszteléséhez egy POST-kérést kell küldenie neki, amely egy JSON formátumú User objektumot tartalmaz. Például a cURL használatával:

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

A függvénynek egy Greeting objektummal kell válaszolnia, szintén JSON formátumban:

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

Íme egy képernyőkép a cURL-kérésről a képernyő tetején, alul pedig a helyi Azure-függvényről:

Azure Function running locally

A függvény helyi hibakeresése

A következő szakaszok a függvény hibakeresését ismertetik.

Hibakeresés az Intellij IDEA használatával

Nyissa meg a projektet az Intellij IDEA-ban, majd hozzon létre egy távoli JVM hibakeresési futtatási konfigurációt a csatoláshoz. További információ: Oktatóanyag: Távoli hibakeresés.

Create a Remote JVM Debug run configuration

Futtassa az alkalmazást a következő paranccsal:

mvn azure-functions:run -DenableDebug

Az alkalmazás indításakor a következő kimenet jelenik meg:

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

Indítsa el a projekt hibakeresését az IntelliJ IDEA-ban. A következő kimenet jelenik meg:

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

Jelölje meg a hibakereséshez használni kívánt töréspontokat. Az Intellij IDEA hibakeresési módot ad meg a kérés elküldése után.

Hibakeresés a Visual Studio Code használatával

Nyissa meg a projektet a Visual Studio Code-ban, majd konfigurálja a következő launch.json fájltartalmat:

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

Futtassa az alkalmazást a következő paranccsal:

mvn azure-functions:run -DenableDebug

Az alkalmazás indításakor a következő kimenet jelenik meg:

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

Indítsa el a projekt hibakeresését a Visual Studio Code-ban, majd jelölje meg a hibakereséshez használni kívánt töréspontokat. A Visual Studio Code hibakeresési módot ad meg a kérés elküldése után. További információ: Java futtatása és hibakeresése.

A függvény üzembe helyezése az Azure Functions szolgáltatásban

Most közzé fogja tenni az Azure-függvényt az éles környezetben. Ne feledje, hogy a <functionAppName>pom.xml fájlban definiált , <functionAppRegion>és <functionResourceGroup> tulajdonságok a függvény konfigurálására szolgálnak.

Megjegyzés:

A Maven beépülő modulnak hitelesítenie kell magát az Azure-ral. Ha telepítve van az Azure CLI, a folytatás előtt használja az login . További hitelesítési lehetőségekért lásd : Hitelesítés az Azure-maven-plugins adattárban.

A függvény automatikus üzembe helyezéséhez futtassa a Mavent:

mvn azure-functions:deploy

Most nyissa meg az Azure Portal, és keresse meg a létrehozott Function App elemet.

Válassza ki a függvényt:

  • A függvény áttekintésében jegyezze fel a függvény URL-címét.
  • A futó függvény ellenőrzéséhez válassza a Naplózás streamelése lehetőséget a navigációs menüben.

Most, ahogy az előző szakaszban is tette, a cURL használatával érheti el a futó függvényt az alábbi példában látható módon. Mindenképpen cserélje le your-function-name a valódi függvény nevét.

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

Az előző szakaszhoz hasonlóan a függvénynek egy Greeting objektummal kell válaszolnia, szintén JSON formátumban:

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

Gratulálunk, létrehozott egy Azure Functions szolgáltatásban futó Spring Cloud-függvényt! A Spring Cloud-függvényekkel kapcsolatos további információkért és mintákért tekintse meg a következő erőforrásokat:

További lépések

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

A Spring használata az Azure-ban