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
- Azure-előfizetés. 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.
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:
- Java Developer Kit, 11-es verzió
- Apache Maven, 3.0-s vagy újabb verzió
- Azure CLI
- Az Azure Functions Core Tools 4-es verziója
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.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");
}
}
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:
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.
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.
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.