Funkce Spring Cloud v Azure

  • Článek

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:

Důležité

  1. K dokončení tohoto rychlého startu JAVA_HOME je nutné nastavit proměnnou prostředí na umístění instalace sady JDK.
  2. Ujistěte se, že verze základních nástrojů je minimálně 4.0.5455.

Co vytvoříme

Vytvoříme klasickou funkci Hello, World, která běží ve službě 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 úložiště azure-function-java-worker na GitHubu. Tuto ukázku můžete použít přímo, pokud chcete vidět konečnou práci popsanou v tomto rychlém startu.

Vytvoření nového projektu Maven

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

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

Poznámka:

Tento soubor použije závislosti Maven z funkcí Spring Boot a Spring Cloud a nakonfiguruje moduly plug-in Maven Spring Boot a Azure Functions.

Potřebujete přizpůsobit několik vlastností pro vaši aplikaci:

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

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

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. Teď vytvoříme naše User objekty a Greeting objekty, které představují 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 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 chceme 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 a 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é tomuto konvenci vytváření názvů. Název se musí shodovat s názvem Azure Functions, který vytvoříme v další části.

Vytvoření funkce Azure Functions

Abychom mohli využívat úplné rozhraní API služby Azure Functions, teď kódujeme funkci Azure Functions, která deleguje její spuštění na funkci Spring Cloud vytvořenou 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 představuje funkci Azure Functions a má následující zajímavé funkce:

  • Třída má poznámku @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řidání testů jednotek

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

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 s požadavkem cURL v horní části obrazovky a místní funkcí Azure v dolní části:

Azure Function running locally

Místní ladění funkce

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

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

Otevřete projekt v Intellij IDEA a pak vytvořte konfiguraci spuštění vzdáleného ladění JVM pro připojení. Další informace naleznete v tématu Kurz: Vzdálené ladění.

Create a Remote JVM Debug run configuration

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 editoru 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 editoru Visual Studio Code a potom 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 ke <functionAppName>konfiguraci funkce se používají vlastnosti a <functionResourceGroup> vlastnosti, <functionAppRegion>které jste definovali v souboru pom.xml.

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 úložišti azure-maven-plugins .

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 v navigační nabídce streamování protokolů.

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

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