Spring Cloud Stream com Barramento de Serviço do Azure

Este artigo demonstra como usar o Spring Cloud Stream Binder para enviar mensagens e receber mensagens de Barramento de Serviço queues e topics.

Azure fornece uma plataforma de mensagens assíncrona chamada Barramento de Serviço do Azure ("Barramento de Serviço") baseada no padrão Advanced Message Queueing Protocol 1.0 ("AMQP 1.0"). Barramento de Serviço pode ser usado no conjunto das plataformas da Azure com suporte.

Pré-requisitos

• Uma assinatura Azure – criar 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 um tópico para Barramento de Serviço do Azure. Se você não tiver uma, criar uma fila Barramento de Serviço ou criar um tópico Barramento de Serviço.

• Um aplicativo Spring Boot. Caso não tiver um, crie um projeto Maven com o Spring Initializr. Selecione Maven Project e, em Dependencies, adicione as dependências Spring Web e Azure Support e selecione Java versão 8 ou superior.

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

Com uma fila ou tópico no Barramento de Serviço do Azure, você pode enviar e receber mensagens utilizando o serviço Spring Cloud Azure Stream Binder Barramento de Serviço.

Para instalar o módulo Barramento de Serviço do Spring Cloud Azure Stream Binder, adicione as seguintes dependências ao arquivo pom.xml:

• O Spring Cloud Azure Lista de Materiais (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.2.0.

  Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.2.0.

  Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

  Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

  Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

• O artefato Barramento de Serviço do Spring Cloud Azure Stream Binder:

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

Codificar o aplicativo

Siga os passos a seguir para configurar seu aplicativo para usar uma fila ou um tópico do Barramento de Serviço para o envio e recebimento de mensagens.

1. Configure as credenciais de Barramento de Serviço no arquivo de configuração application.properties.

   • Use uma fila do Barramento de Serviço
   • Use um tópico do Barramento de Serviç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 seguinte descreve os campos da configuração:

   Campo	Descrição
   spring.cloud.azure.servicebus.namespace	Especifique o namespace obtido em seu Barramento de Serviço no portal do Azure.
   spring.cloud.stream.bindings.consume-in-0.destination	Especifique a fila do Barramento de Serviço ou o tópico do Barramento de Serviço que você usou neste tutorial.
   spring.cloud.stream.bindings.supply-out-0.destination	Especifique o mesmo valor usado para o destino de entrada.
   spring.cloud.stream.servicebus.bindings.consume-in-0.consumer.auto-complete	Especifique se deseja liquidar as mensagens automaticamente. Se definido como false, um cabeçalho de mensagem de Checkpointer será adicionado para permitir que os desenvolvedores resolvam mensagens manualmente.
   spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type	Especifique o tipo de entidade para a associação de saída, pode ser queue ou topic.
   spring.cloud.function.definition	Especifique qual bean funcional deve ser associado aos destinos externos expostos pelas vinculações.
   spring.cloud.stream.poller.fixed-delay	Especifique o atraso fixo para o pesquisador 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 padrão é 0.

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

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

   Dica

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

   DefaultAzureCredential dá suporte a vários métodos de autenticação e determina qual método usar no runtime. Essa abordagem habilita seu aplicativo a usar diferentes métodos de autenticação em diferentes ambientes, 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 locais, você pode usar CLI do Azure, Visual Studio Code, PowerShell ou outros métodos. Para obter mais informações, consulte Autenticação do Azure em Ambientes de Desenvolvimento em Java. Para concluir a autenticação em ambientes de hospedagem Azure, recomendamos usar a identidade gerenciada atribuída pelo usuário. Para obter mais informações, consulte O que são identidades gerenciadas para recursos Azure?

3. Inicie o aplicativo. Mensagens como o exemplo seguinte serão postadas no log do aplicativo:

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

Próximas etapas