Spring Cloud Stream com Azure Event Hubs

Este tutorial demonstra como enviar e receber mensagens usando o Azure Event Hubs e os Eventhubs do Spring Cloud Stream Binder em um aplicativo Spring Boot.

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.
Um hub de eventos Azure. Se você não tiver um, criar um hub de eventos usando Azure portal.
Uma conta Azure Storage para pontos de verificação do hub de eventos. Se você não possuir uma, crie uma conta de armazenamento.
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.

Observação

Para conceder acesso à sua conta aos recursos, em Azure Event Hubs, atribua a função Azure Event Hubs Data Receiver e Azure Event Hubs Data Sender à conta Microsoft Entra que você está usando no momento. Em seguida, na conta Azure Storage, atribua a função Storage Blob Data Contributor à conta 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 Azure e Autorizar acesso aos recursos do Hubs de Eventos usando o Microsoft Entra ID.

Importante

É necessário o Spring Boot versão 2.5 ou superior para concluir as etapas neste tutorial.

Enviar e receber mensagens de Azure Event Hubs

Com uma conta Azure Storage e um hub de eventos Azure, você pode enviar e receber mensagens usando os Hubs de Eventos do Spring Cloud Azure Stream Binder.

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

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>7.1.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.1.0.

Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.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 do Spring Cloud Azure Stream Binder para Hubs de Eventos:

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

Codificar o aplicativo

Use as etapas a seguir para configurar seu aplicativo para produzir e consumir mensagens usando Azure Event Hubs.

Configure as credenciais do hub de eventos adicionando as seguintes propriedades ao arquivo application.properties.

 spring.cloud.azure.eventhubs.namespace=${AZURE_EVENTHUBS_NAMESPACE}
 spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=${AZURE_STORAGE_ACCOUNT_NAME}
 spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=${AZURE_STORAGE_CONTAINER_NAME}
 spring.cloud.stream.bindings.consume-in-0.destination=${AZURE_EVENTHUB_NAME}
 spring.cloud.stream.bindings.consume-in-0.group=${AZURE_EVENTHUB_CONSUMER_GROUP}
 spring.cloud.stream.bindings.supply-out-0.destination=${AZURE_EVENTHUB_NAME}
 spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode=MANUAL
 spring.cloud.function.definition=consume;supply;
 spring.cloud.stream.poller.initial-delay=0
 spring.cloud.stream.poller.fixed-delay=1000

A tabela seguinte descreve os campos da configuração:

Campo	Descrição
`spring.cloud.azure.eventhubs.namespace`	Especifique o namespace obtido no hub de eventos do portal Azure.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name`	Especifique a conta de armazenamento criada neste tutorial.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name`	Especifique o contêiner de sua conta de armazenamento.
`spring.cloud.stream.bindings.consume-in-0.destination`	Especifique o hub de eventos que você usou neste tutorial.
`spring.cloud.stream.bindings.consume-in-0.group`	Especifique os grupos de consumidores em sua instância dos Hubs de Eventos.
`spring.cloud.stream.bindings.supply-out-0.destination`	Especifique o mesmo hub de eventos que você usou neste tutorial.
`spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode`	Especifique `MANUAL`.
`spring.cloud.function.definition`	Especifique qual bean funcional deve ser vinculado aos destinos externos expostos pelas vinculações.
`spring.cloud.stream.poller.initial-delay`	Especifique o atraso inicial para gatilhos periódicos. O valor padrão é `0`.
`spring.cloud.stream.poller.fixed-delay`	Especifique o atraso fixo para o instrumento de sondagem padrão em milissegundos. O valor padrão é `1000 L`.

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

import com.azure.spring.messaging.checkpoint.Checkpointer;
import com.azure.spring.messaging.eventhubs.support.EventHubsHeaders;
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 EventHubBinderApplication implements CommandLineRunner {

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

    public static void main(String[] args) {
        SpringApplication.run(EventHubBinderApplication.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: '{}', partition key: {}, sequence number: {}, offset: {}, enqueued "
                    +"time: {}",
                message.getPayload(),
                message.getHeaders().get(EventHubsHeaders.PARTITION_KEY),
                message.getHeaders().get(EventHubsHeaders.SEQUENCE_NUMBER),
                message.getHeaders().get(EventHubsHeaders.OFFSET),
                message.getHeaders().get(EventHubsHeaders.ENQUEUED_TIME)
            );
            checkpointer.success()
                        .doOnSuccess(success->LOGGER.info("Message '{}' successfully checkpointed",
                            message.getPayload()))
                        .doOnError(error->LOGGER.error("Exception found", error))
                        .block();
        };
    }

    @Override
    public void run(String... args) {
        LOGGER.info("Going to add message {} to sendMessage.", "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 Azure CLI, 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?

Inicie o aplicativo. Mensagens como essa serão postadas no log do aplicativo, conforme mostrado na saída de exemplo a seguir:

New message received: 'Hello World', partition key: 107207233, sequence number: 458, offset: 94256, enqueued time: 2023-02-17T08:27:59.641Z
Message 'Hello World!' successfully checkpointed

Implantar em Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para produção. Azure Spring Apps facilita a implantação de aplicativos Spring Boot para Azure sem alterações de código. O serviço gerencia a infraestrutura dos aplicativos do Spring para que os desenvolvedores possam se concentrar no código. Azure Spring Apps fornece gerenciamento de ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviço, integração de CI/CD, implantações azul-verde e muito mais. Para implantar seu aplicativo em Azure Spring Apps, consulte Deploy seu primeiro aplicativo para Azure Spring Apps.

Próximas etapas

Azure para desenvolvedores Spring Amostras do Spring Cloud Azure Stream Binder Event Hubs

Comentários

Esta página foi útil?

Last updated on 2026-03-11