Spring Cloud Stream com o Azure Service Bus

  • Artigo

Este artigo demonstra como utilizar o Spring Cloud Stream Binder para enviar e receber mensagens do Azure Service Bus queues e topics.

O Azure fornece uma plataforma de mensagens assíncrona chamada Azure Service Bus ("Service Bus"), que se baseia no padrão Advanced Message Queueing Protocol 1.0 ("AMQP 1.0"). É possível utilizar o Service Bus em toda a gama de plataformas do Azure suportadas.

Pré-requisitos

  • Uma assinatura do Azure - crie uma gratuitamente.

  • Java Development Kit (JDK) versão 8 ou superior.

  • Apache Maven, versão 3.2 ou superior.

  • cURL ou um utilitário HTTP semelhante para testar a funcionalidade.

  • Uma fila ou tópico para o Barramento de Serviço do Azure. Se você não tiver um, crie uma fila do Service Bus ou crie um tópico do Service Bus.

  • Um aplicativo Spring Boot. Se você não tiver um, crie um projeto Maven com o Spring Initializr. Certifique-se de selecionar Projeto Maven e, em Dependências, adicione as dependências do Spring Web e do Suporte do Azure e, em seguida, selecione Java versão 8 ou superior.

Nota

Para conceder à sua conta acesso aos recursos do Barramento de Serviço do Azure, atribua a Azure Service Bus Data Sender função e Azure Service Bus Data Receiver à conta do Microsoft Entra que você está usando no momento. Para obter mais informações sobre como conceder funções de acesso, consulte Atribuir funções do Azure usando o portal do Azure e Autenticar e autorizar um aplicativo com ID do Microsoft Entra para acessar entidades do Barramento de Serviço do Azure.

Importante

O Spring Boot versão 2.5 ou superior é necessário para concluir as etapas neste artigo.

Enviar e receber mensagens do Barramento de Serviço do Azure

Com uma fila ou tópico para o Barramento de Serviço do Azure, você pode enviar e receber mensagens usando o Spring Cloud Azure Stream Binder Service Bus.

Para instalar o módulo do Spring Cloud Azure Stream Binder Service Bus, adicione as seguintes dependências ao seu arquivo pom.xml :

  • A lista de materiais (BOM) do Azure Spring Cloud:

    <dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>5.11.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

    Nota

    Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para essa lista técnica, consulte Qual versão do Spring Cloud Azure devo usar.

  • O artefato do Spring Cloud Azure Stream Binder Service Bus:

    <dependency>
     <groupId>com.azure.spring</groupId>
     <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
</dependency>

Codificar a aplicação

Use as etapas a seguir para configurar seu aplicativo para usar uma fila ou tópico do Service Bus para enviar e receber mensagens.

  1. Configure as credenciais do Service Bus no arquivo de application.propertiesconfiguração .

     spring.cloud.azure.servicebus.namespace=${AZURE_SERVICEBUS_NAMESPACE}
 spring.cloud.stream.bindings.consume-in-0.destination=${AZURE_SERVICEBUS_QUEUE_NAME}
 spring.cloud.stream.bindings.supply-out-0.destination=${AZURE_SERVICEBUS_QUEUE_NAME}
 spring.cloud.stream.servicebus.bindings.consume-in-0.consumer.auto-complete=false
 spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue
 spring.cloud.function.definition=consume;supply;
 spring.cloud.stream.poller.fixed-delay=60000 
 spring.cloud.stream.poller.initial-delay=0

    A tabela a seguir descreve os campos na configuração:

    Campo Descrição
    spring.cloud.azure.servicebus.namespace Especifique o namespace obtido em seu Service Bus no portal do Azure.
    spring.cloud.stream.bindings.consume-in-0.destination Especifique a fila ou o tópico do Service Bus que utilizou neste tutorial.
    spring.cloud.stream.bindings.supply-out-0.destination Especifique o valor que foi utilizado para o destino de entrada.
    spring.cloud.stream.servicebus.bindings.consume-in-0.consumer.auto-complete Especifique se as mensagens devem ser liquidadas automaticamente. Se definido como false, um cabeçalho de mensagem de Checkpointer será adicionado para permitir que os desenvolvedores liquidem as mensagens manualmente.
    spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type Especifique o tipo de entidade para a ligação de saída, pode ser queue ou topic.
    spring.cloud.function.definition Especifique qual bean funcional deve ser vinculado ao(s) destino(s) externo(s) exposto(s) pelas associações.
    spring.cloud.stream.poller.fixed-delay Especifique o atraso fixo para o poller padrão em milissegundos. O valor padrão é 1000 L. O valor recomendado é 60000.
    spring.cloud.stream.poller.initial-delay Especifique o atraso inicial para gatilhos periódicos. O valor predefinido é 0.

  2. Edite o arquivo de classe de inicialização para mostrar o seguinte conteúdo.

    import com.azure.spring.messaging.checkpoint.Checkpointer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
import java.util.function.Consumer;
import java.util.function.Supplier;
import static com.azure.spring.messaging.AzureHeaders.CHECKPOINTER;

@SpringBootApplication
public class ServiceBusQueueBinderApplication implements CommandLineRunner {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceBusQueueBinderApplication.class);
    private static final Sinks.Many<Message<String>> many = Sinks.many().unicast().onBackpressureBuffer();

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueBinderApplication.class, args);
    }

    @Bean
    public Supplier<Flux<Message<String>>> supply() {
        return ()->many.asFlux()
                       .doOnNext(m->LOGGER.info("Manually sending message {}", m))
                       .doOnError(t->LOGGER.error("Error encountered", t));
    }

    @Bean
    public Consumer<Message<String>> consume() {
        return message->{
            Checkpointer checkpointer = (Checkpointer) message.getHeaders().get(CHECKPOINTER);
            LOGGER.info("New message received: '{}'", message.getPayload());
            checkpointer.success()
                        .doOnSuccess(s->LOGGER.info("Message '{}' successfully checkpointed", message.getPayload()))
                        .doOnError(e->LOGGER.error("Error found", e))
                        .block();
        };
    }

    @Override
    public void run(String... args) {
        LOGGER.info("Going to add message {} to Sinks.Many.", "Hello World");
        many.emitNext(MessageBuilder.withPayload("Hello World").build(), Sinks.EmitFailureHandler.FAIL_FAST);
    }

}

    Gorjeta

    Neste tutorial, não há operações de autenticação nas configurações ou no código. No entanto, conectar-se aos serviços do Azure requer autenticação. Para concluir a autenticação, você precisa usar a Identidade do Azure. O Spring Cloud Azure usa DefaultAzureCredentialo , que a biblioteca de Identidades do Azure fornece para ajudá-lo a obter credenciais sem alterações de código.

    DefaultAzureCredential Suporta vários métodos de autenticação e determina qual método usar em tempo de execução. Essa abordagem permite que seu aplicativo use diferentes métodos de autenticação em ambientes diferentes (como ambientes locais e de produção) sem implementar código específico do ambiente. Para obter mais informações, consulte DefaultAzureCredential.

    Para concluir a autenticação em ambientes de desenvolvimento local, você pode usar a CLI do Azure, o Visual Studio Code, o PowerShell ou outros métodos. Para obter mais informações, consulte Autenticação do Azure em ambientes de desenvolvimento Java. Para concluir a autenticação em ambientes de hospedagem do Azure, recomendamos o uso da identidade gerenciada atribuída pelo usuário. Para obter mais informações, consulte O que são identidades gerenciadas para recursos do Azure?

  3. Inicie a aplicação. Mensagens como o exemplo a seguir serão postadas no log do aplicativo:

    New message received: 'Hello World'
Message 'Hello World' successfully checkpointed

Próximos passos

Azure para desenvolvedoresdo Spring Exemplos do Spring Cloud Azure Stream Binder Service Bus