Função Spring Cloud no Azure

Este artigo mostra-lhe como construir, testar, depurar e implementar uma Função Cloud Spring em Java no Funções do Azure. Quando terminar, a sua função é executada no Plano de Consumo e responde a pedidos HTTP.

Pré-requisitos

Para desenvolver funções usando Java, instale as seguintes ferramentas:

Importante

Defina a variável de ambiente JAVA_HOME com a localização de instalação do JDK para concluir este guia de introdução rápida.

Certifique-se de que a versão da sua ferramenta principal é pelo menos 4.0.5455.

O que vais construir

Vais criar uma função clássica "Hello, World" que corre no Funções do Azure e está configurada com o Spring Cloud Function.

A função recebe um User objeto JSON, que contém um nome de utilizador, e envia de volta um Greeting objeto, que contém a mensagem de boas-vindas para esse utilizador.

O projeto está disponível na amostra Spring Cloud Function in Azure do azure-function-java-worker repositório no GitHub. Você pode usar esse exemplo diretamente caso deseje ver o trabalho final descrito neste guia de início rápido.

Criar um novo projeto do Maven

Cria um projeto Maven vazio e configura-o com o Spring Cloud Function e o Funções do Azure.

Numa pasta vazia, crie um novo ficheiropom.xml . Depois, copie o conteúdo do ficheiro pom.xml do projeto de exemplo.

Nota

Este ficheiro utiliza dependências do Maven tanto do Spring Boot como do Spring Cloud Function. Também configura os plugins Spring Boot e Funções do Azure Maven.

Personalize algumas propriedades para a sua aplicação:

  • <functionAppName>é o nome da sua Função Azure.
  • <functionAppRegion>é o nome da região Azure onde implementas a tua Função.
  • <functionResourceGroup>é o nome do grupo de recursos Azure que estás a usar.

Altere essas propriedades diretamente perto da parte superior do arquivo pom.xml , conforme mostrado no exemplo a seguir:

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

Criar ficheiros de configuração do Azure

Crie uma pasta src/main/resources e adicione os seguintes arquivos de configuração do Funções do Azure a ela.

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": ""
  }
}

Criar objetos de domínio

As Funções do Azure podem receber e enviar objetos no formato JSON. Crie objetos User e Greeting que representem o seu modelo de domínio. Podes criar objetos mais complexos com mais propriedades se quiseres personalizar este quickstart.

Crie uma pasta src/main/java/com/exemplo/model e adicione os dois ficheiros seguintes:

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

Criar a aplicação Spring Boot

Esta aplicação gere toda a lógica de negócio e tem acesso ao ecossistema completo do Spring Boot. Esse recurso oferece dois benefícios principais em relação a uma Função do Azure padrão:

  • Ele não depende das APIs do Funções do Azure, portanto, você pode portá-lo facilmente para outros sistemas. Por exemplo, você pode reutilizá-lo em um aplicativo Spring Boot normal.
  • Você pode usar todas as @Enable anotações do Spring Boot para adicionar novos recursos.

Na pasta sRC/main/java/com/exemplo, crie o seguinte ficheiro, que é uma aplicação Spring Boot normal:

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

Agora crie o seguinte arquivo na pasta src/main/java/com/example/hello . Este código contém um componente Spring Boot que representa a Função que pretende executar:

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

Nota

A função Hello é bastante específica:

  • É um java.util.function.Function. Ele contém a lógica de negócios e usa uma API Java padrão para transformar um objeto em outro.
  • Como tem a @Component anotação, é um Spring Bean. Por defeito, o seu nome é o mesmo da classe, mas começa com um carácter minúsculo: hello. Seguir essa convenção de nomenclatura é importante se você quiser criar outras funções em seu aplicativo. O nome deve corresponder ao nome Funções do Azure que cria na secção seguinte.

Criar a Função do Azure

Para usar a API completa do Funções do Azure, crie uma Azure Function que delegue a sua execução à Spring Cloud Function que criou no passo anterior.

Na pasta src/main/java/com/example/hello, crie o seguinte arquivo de classe de função do Azure:

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

Esta classe Java é uma Função Azure com as seguintes características:

  • A classe tem a @Component anotação, logo, é um Spring Bean.
  • O nome da função, conforme definido pela @FunctionName("hello") anotação, é hello.
  • A classe implementa uma Função do Azure real, para que você possa usar a API completa do Funções do Azure aqui.

Adicionar testes de unidades

Esta etapa é opcional, mas recomendada para validar se o aplicativo funciona corretamente.

Crie uma pasta src/test/java/com/example e adicione os seguintes testes 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");
    }
}

Agora pode testar a sua Função Azure usando o Maven:

mvn clean test

Executar a Função localmente

Antes de implantar a sua aplicação no Azure Function, teste-a localmente.

Primeiro, embale a sua candidatura num ficheiro JAR:

mvn package

Agora que a aplicação está embalada, execute-a usando o azure-functions plugin Maven:

mvn azure-functions:run

A Função Azure está agora disponível no seu localhost, usando a porta 7071. Teste a função enviando-lhe um pedido POST, com um User objeto em formato JSON. Por exemplo, use cURL:

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

A Função responde com um Greeting objeto, em formato JSON:

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

Aqui está uma captura de tela da solicitação cURL na parte superior da tela e a Função do Azure local na parte inferior:

Função do Azure a ser executada localmente

Depurar a função localmente

As seções a seguir descrevem como depurar a função.

Depurar usando Intellij IDEA

Abra o projeto no IntelliJ IDEA e, em seguida, crie uma configuração de execução Remote JVM Debug para estabelecer ligação. Para obter mais informações, consulte Tutorial: Depuração remota.

Criar uma configuração de execução de depuração JVM remota

Execute o aplicativo com o seguinte comando:

mvn azure-functions:run -DenableDebug

Quando o aplicativo é iniciado, você vê a seguinte saída:

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

Inicie a depuração do projeto no IntelliJ IDEA. Você vê a seguinte saída:

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

Marque os pontos de interrupção que deseja depurar. O IntelliJ IDEA entra em modo de depuração após enviar um pedido.

Depurar usando o Visual Studio Code

Abra o projeto no Visual Studio Code e, em seguida, configure o seguinte conteúdo do ficheiro launch.json:

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

Execute o aplicativo com o seguinte comando:

mvn azure-functions:run -DenableDebug

Quando o aplicativo é iniciado, você vê a seguinte saída:

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

Começa a depurar projetos no Visual Studio Code e depois marca os pontos de interrupção que queres depurar. O Visual Studio Code entra no modo de depuração após enviar uma solicitação. Para obter mais informações, consulte Executando e depurando Java.

Implementar a Função nas Funções do Azure

Agora, vais publicar a Função do Azure para produção. Lembre-se de que o <functionAppName>, <functionAppRegion>e <functionResourceGroup> as propriedades que você definiu no arquivo pom.xml são usados para configurar sua função.

Nota

O plug-in do Maven precisa ser autenticado com o Azure. Se você tiver a CLI do Azure instalada, use az login antes de continuar.

Para mais opções de autenticação, consulte Autenticação no azure-maven-plugins repositório.

Execute o Maven para implementar automaticamente a função:

mvn azure-functions:deploy

Em seguida, aceda ao portal do Azure para localizar o Function App criado.

Selecione a função:

  • Na descrição geral da função, anote o URL da mesma.
  • Para verificar a função de execução, selecione Registrar streaming no menu de navegação.

Agora, como você fez na seção anterior, use cURL para acessar a função em execução, como mostrado no exemplo a seguir. Certifique-se de substituir your-function-name pelo seu nome de função real.

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

Tal como na secção anterior, a Função deverá responder com um objeto Greeting, ainda no formato JSON:

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

Parabéns! Tem uma função do Spring Cloud Function em execução nas Funções do Azure! Para obter mais informações e exemplos de funções do Spring Cloud, consulte os seguintes recursos:

Próximos passos

Para saber mais sobre o Spring e o Azure, avance para o centro de documentação relativa ao Spring no Azure.

Spring no Azure

  • Last updated on