Megosztás a következőn keresztül:

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

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

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

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.

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.

Feljegyzé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, az alábbi példában látható módon:

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

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 User az objektumainkatGreeting, 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");
    }
}

Feljegyzé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:

Helyileg futó Azure-függvény

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.

Távoli JVM-hibakeresési futtatási konfiguráció létrehozása

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<functionAppRegion>definiált , <functionResourceGroup>és tulajdonságok a függvény konfigurálására szolgálnak.

Feljegyzé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:

Következő 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

  • Last updated on