Spring Cloud Function v platformě Azure

V tomto článku se dozvíte, jak sestavit, otestovat, ladit a nasadit funkci Java Spring Cloud v Azure Functions. Až budete hotovi, vaše funkce běží v plánu Consumption a reaguje na požadavky HTTP.

Požadavky

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

Pokud chcete vyvíjet funkce pomocí Java, nainstalujte následující nástroje:

• Java Developer Kit, verze 11
• Apache Maven verze 3.0 nebo vyšší
• Azure CLI
• Azure Functions Core Tools verze 4

Důležité

Nastavte proměnnou JAVA_HOME prostředí na umístění instalace sady JDK a dokončete tento rychlý start.

Ujistěte se, že verze základních nástrojů je minimálně 4.0.5455.

Co budete vytvářet

Vytvoříte klasickou funkci "Hello, World", která běží na Azure Functions a je nakonfigurovaná pomocí funkce Spring Cloud.

Funkce obdrží User objekt JSON, který obsahuje uživatelské jméno, a odešle zpět Greeting objekt, který obsahuje uvítací zprávu pro daného uživatele.

Projekt je k dispozici ve funkci Spring Cloud v Azure v ukázce azure-function-java-worker úložiště na GitHubu. Tuto ukázku můžete použít přímo, pokud chcete vidět hotovou práci popsanou v tomto úvodním průvodci.

Vytvoření nového projektu Maven

Vytvořte prázdný projekt Maven a nakonfigurujte ho pomocí funkce Spring Cloud a Azure Functions.

V prázdné složce vytvořte nový souborpom.xml . Potom zkopírujte obsah ze souboru pom.xml ukázkového projektu.

Poznámka:

Tento soubor používá závislosti Mavenu z funkce Spring Boot i Spring Cloud. Nakonfiguruje také moduly plug-in Spring Boot a Azure Functions Maven.

Přizpůsobte si několik vlastností pro vaši aplikaci:

• <functionAppName>je název funkce Azure.
• <functionAppRegion>je název Azure oblasti, do které funkci nasadíte.
• <functionResourceGroup>je název Azure skupiny prostředků, kterou používáte.

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

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

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

Vytvořte složku src/main/resources a přidejte do ní následující konfigurační soubory 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": ""
  }
}

Vytvoření objektů domén

Azure Functions může přijímat a odesílat objekty ve formátu JSON. Vytvořte objekty User a Greeting, které představují váš doménový model. Pokud chcete přizpůsobit tento rychlý start, 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 spravuje veškerou obchodní logiku a má přístup k celému ekosystému Spring Boot. Tato funkce poskytuje dvě hlavní výhody oproti standardní funkci Azure Functions:

• Nespoléhá na rozhraní API služby Azure Functions, takže ho můžete snadno přenést do jiných systémů. Můžete ho například znovu použít v normální aplikaci Spring Boot.
• K přidání nových funkcí můžete použít všechny @Enable poznámky z Spring Bootu.

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

Teď ve složce src/main/java/com/example/hello vytvořte následující soubor. Tento kód obsahuje komponentu Spring Boot, která představuje funkci, kterou chcete spustit:

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

Poznámka:

Funkce Hello je poměrně specifická:

• Je to java.util.function.Function. Obsahuje obchodní logiku a používá standardní rozhraní Java API k transformaci jednoho objektu do druhého.
• Protože má poznámku @Component , je to Spring Bean. Ve výchozím nastavení je jeho název stejný jako třída, ale začíná malými písmeny: hello. Pokud chcete ve své aplikaci vytvořit další funkce, je důležité držet se této konvence pojmenovávání. Název se musí shodovat s názvem Azure Functions, který vytvoříte v další části.

Vytvoření funkce Azure Functions

Pokud chcete použít úplné rozhraní API Azure Functions, vytvořte funkci Azure, která deleguje její spuštění na funkci Spring Cloud, kterou jste vytvořili v předchozím kroku.

Ve složce src/main/java/com/example/hello vytvořte následující soubor třídy funkce Azure Functions:

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

Tato třída Java je funkce Azure s následujícími funkcemi:

• Třída má anotaci @Component, takže je to Spring Bean.
• Název funkce, jak je definováno poznámkou @FunctionName("hello") , je hello.
• Třída implementuje skutečnou funkci Azure Functions, takže zde můžete použít úplné rozhraní API služby Azure Functions.

Přidejte jednotkové testy

Tento krok je nepovinný, ale doporučuje se ověřit, že 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.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");
    }
}

Funkci Azure teď můžete otestovat pomocí Mavenu:

mvn clean test

Místní spuštění funkce

Než aplikaci nasadíte do funkce Azure, otestujte ji místně.

Nejprve zabalte aplikaci do souboru JAR:

mvn package

Teď, když je aplikace zabalená, ji spusťte pomocí modulu plug-in azure-functions Maven:

mvn azure-functions:run

Funkce Azure je teď dostupná na místním hostiteli pomocí portu 7071. Otestujte funkci odesláním požadavku POST s objektem User ve formátu JSON. Například použijte cURL:

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

Funkce odpoví objektem Greeting ve formátu JSON:

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

Tady je snímek obrazovky s požadavkem cURL v horní části obrazovky a místní funkcí Azure v dolní části:

Ladění funkce na místním zařízení

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

Ladění s využitím Intellij IDEA

Otevřete projekt v IntelliJ IDEA a potom vytvořte konfiguraci spuštění Remote JVM Debug, abyste se mohli připojit. Viz Návod: Vzdálené ladění pro více informací.

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 IDEA. Zobrazí se následující výstup:

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

Označte zarážky, které chcete ladit. IntelliJ IDEA přejde po odeslání požadavku do režimu ladění.

Ladění pomocí editoru Visual Studio Code

Otevřete projekt v Visual Studio Code a 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 označte zarážky, které chcete ladit. Visual Studio Code po odeslání požadavku přejde do režimu ladění. Další informace najdete v tématu Spuštění a ladění Javy.

Nasazení funkce do Azure Functions

Teď publikujete funkci Azure Functions do produkčního prostředí. Nezapomeňte, že vlastnosti <functionAppName>, <functionAppRegion> a <functionResourceGroup> definované ve vašem souboru pom.xml se používají ke konfiguraci vaší funkce.

Poznámka:

Modul plug-in Maven se musí ověřit v Azure. Pokud máte nainstalované Rozhraní příkazového řádku Azure, použijte az login před pokračováním.

Další možnosti ověřování najdete v tématu Ověřování v azure-maven-plugins úložišti.

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 Function App.

Vyberte funkci:

• Poznamenejte si adresu URL funkce uvedenou v přehledu.
• Pokud chcete zkontrolovat spuštěnou funkci, vyberte Log streaming v navigační nabídce.

Jak jste to udělali v předchozí části, použijte cURL pro přístup ke spuštěné funkci, jak je znázorněno v následujícím příkladu. Nezapomeňte nahradit your-function-name názvem skutečné 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ší informace a ukázky funkcí Spring Cloud najdete v následujících zdrojích informací:

• Blog o funkcích Spring Cloud
• Referenční dokumenty k funkcím Spring Cloud
• Ukázky funkcí Spring Cloud

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.

Spring v Azure