Začínáme s funkcí Spring Cloud v Azure

Tento článek popisuje použití funkcí Spring Cloud k vývoji funkce Java a jejímu publikování ve službě Azure Functions. Až budete hotovi, kód funkce poběží v plánu Consumption v Azure a je možné ho aktivovat prostřednictvím požadavku HTTP.

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet před tím, než začnete.

Požadavky

K vývoji funkcí pomocí Javy musíte mít nainstalovaný následující software:

• Java Developer Kit, verze 11
• Apache Maven verze 3.0 nebo novější
• Azure CLI
• Azure Functions Core Tools verze 3.0.13901.0 nebo vyšší

Co se chystáme sestavit

Vytvoříme klasických funkcí "Hello, World", která běží na Azure Functions a která je nakonfigurovaná pomocí funkce jarní Cloud.

Obdrží jednoduchý User objekt JSON, který obsahuje uživatelské jméno, a pošle zpátky Greeting objekt, který obsahuje uvítací zprávu pro daného uživatele.

Projekt, který sestavíme, je k dispozici ve službě Hello-jaře-Function – Azure úložiště v GitHub. Toto ukázkové úložiště můžete použít přímo, pokud chcete zobrazit poslední práci popsanou v tomto rychlém startu.

Vytvoření nového projektu Maven

Vytvoříme prázdný projekt Maven a nakonfigurujeme ho pomocí jarní cloudové funkce a Azure Functions.

V prázdné složce vytvořte nový soubor pom.xml a zkopírujte nebo vložte obsah z ukázkového souboru projektu pom.xml .

Pro svou aplikaci budete muset přizpůsobit několik vlastností:

• <functionAppName> je název funkce Azure Functions.
• <functionAppRegion> je název oblasti Azure, ve které je vaše funkce nasazena.
• <functionResourceGroup> je název skupiny prostředků Azure, kterou používáte.

Tyto vlastnosti změňte přímo v horní části pom.xml souboru, jak je znázorněno v následujícím příkladu:

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>11</maven.compiler.source>
  <maven.compiler.target>11</maven.compiler.target>

  <azure.functions.java.library.version>1.4.2</azure.functions.java.library.version>
  <azure.functions.maven.plugin.version>1.13.0</azure.functions.maven.plugin.version>

  <!-- customize those two properties. The functionAppName should be unique across Azure -->
  <functionResourceGroup>my-spring-function-resource-group</functionResourceGroup>
  <functionAppName>my-spring-function</functionAppName>

  <functionAppRegion>westeurope</functionAppRegion>
  <stagingDirectory>${project.build.directory}/azure-functions/${functionAppName}</stagingDirectory>
  <start-class>com.example.DemoApplication</start-class>
</properties>

Vytvoření konfiguračních souborů Azure

Vytvořte složku src/main/azure a přidejte do ní následující konfigurační soubory Azure Functions.

host.json:

{
  "version": "2.0",
  "functionTimeout": "00:10:00"
}

local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "MAIN_CLASS":"com.example.DemoApplication",
    "AzureWebJobsDashboard": ""
  }
}

Vytvoření objektů domén

Azure Functions může přijímat a odesílat objekty ve formátu JSON. Nyní vytvoříme naše User a Greeting objekty, které reprezentují náš doménový model. Pokud si chcete přizpůsobit tento rychlý start, aby byl pro vás zajímavější, můžete vytvořit složitější objekty s více vlastnostmi.

Vytvořte složku src/main/java/com/example/model a přidejte do ní následující dva soubory:

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

Vytvoření aplikace Spring Boot

Tato aplikace bude spravovat veškerou obchodní logiku a bude mít přístup k celému ekosystému Spring Boot. Tato funkce poskytuje dvě hlavní výhody oproti standardní funkci Azure:

• Nespoléhá se na rozhraní API Azure Functions, takže je můžete snadno přenést na jiné systémy. Můžete ho například znovu použít v normální aplikaci pro spuštění pružiny.
• @EnableK přidání nových funkcí můžete použít všechny poznámky ze jarního spuštění.

Ve složce src/main/java/com/example vytvořte následující soubor, což je normální aplikace 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);
    }
}

Nyní vytvořte následující soubor, který obsahuje komponentu pružinového spuštění, která představuje funkci, kterou chceme spustit:

Hello. Java:

package com.example;

import com.example.model.Greeting;
import com.example.model.User;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

import java.util.function.Function;

@Component
public class Hello implements Function<Mono<User>, Mono<Greeting>> {

    public Mono<Greeting> apply(Mono<User> mono) {
        return mono.map(user -> new Greeting("Hello, " + user.getName() + "!\n"));
    }
}

Vytvoření funkce Azure Functions

Abychom využili výhod celého Azure Functions API, teď nasadíme funkci Azure, která bude delegovat její provádění na jarní cloudovou funkci, kterou jsme vytvořili v předchozím kroku.

Ve složce Src/Main/Java/com/example vytvořte následující soubor třídy funkce Azure Functions:

HelloHandler.java:

package com.example;

import com.example.model.Greeting;
import com.example.model.User;
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 org.springframework.cloud.function.adapter.azure.FunctionInvoker;

import java.util.Optional;

public class HelloHandler extends FunctionInvoker<User, Greeting> {

    @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(handleRequest(user, context))
            .header("Content-Type", "application/json")
            .build();
    }
}

Tato třída Java představuje funkci Azure Functions a má následující zajímavé funkce:

• Rozšiřuje FunctionInvoker , což vytvoří propojení mezi Azure functions a jarními cloudových funkcí. FunctionInvoker poskytuje handleRequest() metodu, která se používá v body() metodě.
• Název funkce, jak je definován v @FunctionName("hello") poznámce, je hello .
• Je to skutečná funkce Azure, takže tady můžete použít plné Azure Functions rozhraní API.

Přidání testů jednotek

Tento krok je nepovinný, ale doporučuje se ověřit, jestli aplikace funguje správně.

Vytvořte složku Src/test/Java/com/example a přidejte následující testy JUnit:

HelloTest. Java:

package com.example;

import com.example.model.Greeting;
import com.example.model.User;
import com.microsoft.azure.functions.ExecutionContext;
import org.junit.jupiter.api.Test;
import org.springframework.cloud.function.adapter.azure.FunctionInvoker;
import reactor.core.publisher.Mono;

import java.util.logging.Logger;

import static org.assertj.core.api.Assertions.assertThat;

public class HelloTest {

    @Test
    public void test() {
        Mono<Greeting> result = new Hello().apply(Mono.just(new User("foo")));
        assertThat(result.block().getMessage()).isEqualTo("Hello, foo!\n");
    }

    @Test
    public void start() {
        FunctionInvoker<User, Greeting> handler = new FunctionInvoker<>(
            Hello.class);
        Greeting result = handler.handleRequest(new User("foo"), new ExecutionContext() {
            @Override
            public Logger getLogger() {
                return Logger.getLogger(HelloTest.class.getName());
            }

            @Override
            public String getInvocationId() {
                return "id1";
            }

            @Override
            public String getFunctionName() {
                return "hello";
            }
        });
        handler.close();
        assertThat(result.getMessage()).isEqualTo("Hello, foo!\n");
    }
}

Nyní můžete funkci Azure Functions otestovat pomocí Mavenu:

mvn clean test

Místní spuštění funkce

Než aplikaci nasadíme do Azure Functions, otestujeme ji místně.

Nejprve je třeba zabalit aplikaci do souboru Jar:

mvn package

Když je aplikace zabalená, můžete ji spustit pomocí modulu plug-in azure-functions v Mavenu:

mvn azure-functions:run

Funkce Azure Functions by nyní měla být dostupná na localhostu přes port 7071. Funkci můžete otestovat tak, že jí odešlete požadavek POST s objektem User ve formátu JSON. Například pomocí cURL:

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

Funkce by měla jako odpověď poslat objekt Greeting ve formátu JSON:

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

Tady je snímek obrazovky žádosti o otočení v horní části obrazovky a místní funkce Azure v dolní části:

Místní ladění funkce

Následující části popisují, jak tuto funkci ladit.

Ladění pomocí IntelliJ NÁPADu

Otevřete projekt v IntelliJ nápad a pak vytvořte konfiguraci vzdáleného ladění JVM pro připojení. Další informace najdete v tématu kurz: vzdálené ladění.

Spusťte aplikaci pomocí následujícího příkazu:

mvn azure-functions:run -DenableDebug

Po spuštění aplikace se zobrazí následující výstup:

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

Spusťte ladění projektu v IntelliJ nápad. Měl by se zobrazit následující výstup:

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

Označte zarážky, které chcete ladit. Po odeslání žádosti IntelliJ nápad zadá režim ladění.

Ladění pomocí Visual Studio Code

otevřete projekt v Visual Studio Code a pak nakonfigurujte následující obsah souboru launch. json :

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

Spusťte aplikaci pomocí následujícího příkazu:

mvn azure-functions:run -DenableDebug

Po spuštění aplikace se zobrazí následující výstup:

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

spusťte ladění projektu v Visual Studio Code a potom označte zarážky, které chcete ladit. po odeslání žádosti Visual Studio Code zadá režim ladění. Další informace najdete v tématu spuštění a ladění Java.

Nasazení funkce do Azure Functions

Teď funkci Azure Function publikujete do produkčního prostředí. Nezapomeňte, že ke konfiguraci funkce se použije vlastnosti , a , které jste definovali v <functionAppName><functionAppRegion><functionResourceGroup><functionAppName> souboru.

Spusťte Maven a nasaďte funkci automaticky:

mvn azure-functions:deploy

Nyní přejděte na web Azure Portal a vyhledejte vytvořenou aplikaci .

Vyberte funkci :

• Poznamenejte si adresu URL funkce uvedenou v přehledu.
• Na kartě Funkce platformy vyhledejte službu streamování protokolů a potom ji vyberte, abyste mohli zkontrolovat spuštěnou funkci.

Teď, stejně jako v předchozí části, použijte cURL pro přístup k běžící funkci, jak je znázorněno v následujícím příkladu. Nezapomeňte nahradit your-function-name skutečným názvem vaší funkce.

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

Stejně jako v předchozí části by funkce měla jako odpověď poslat objekt Greeting ve formátu JSON:

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

Blahopřejeme, vaše funkce Spring Cloud běží v Azure Functions!

Další kroky

Pokud se chcete dozvědět více o architektuře Spring a Azure, přejděte do centra dokumentace Spring v Azure.