Spring Cloud Stream avec Azure Event Hubs

Ce tutoriel montre comment envoyer et recevoir des messages à l’aide d’Azure Event Hubs et spring Cloud Stream Binder Eventhubs dans une application Spring Boot.

Prérequis

Remarque

Pour accorder à votre compte l’accès aux ressources, dans Azure Event Hubs, attribuez le rôle et Azure Event Hubs Data Sender le Azure Event Hubs Data Receiver rôle au compte Microsoft Entra que vous utilisez actuellement. Ensuite, dans le compte Stockage Azure, attribuez le Storage Blob Data Contributor rôle au compte Microsoft Entra que vous utilisez actuellement. Pour plus d’informations sur l’octroi de rôles d’accès, consultez Affecter des rôles Azure à l’aide des Portail Azure et autoriser l’accès aux ressources Event Hubs à l’aide de l’ID Microsoft Entra.

Important

Spring Boot version 2.5 ou ultérieure est nécessaire pour suivre les étapes décrites dans ce didacticiel.

Envoyer et recevoir des messages d’Azure Event Hubs

Avec un compte Stockage Azure et un hub d’événements Azure, vous pouvez envoyer et recevoir des messages à l’aide de Spring Cloud Azure Stream Binder Event Hubs.

Pour installer le module Spring Cloud Azure Stream Binder Event Hubs, ajoutez les dépendances suivantes à votre fichier pom.xml :

  • The Spring Cloud Azure Bill of Materials (BOM) :

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

    Remarque

    Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.16.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

  • Artefact Event Hubs Spring Cloud Azure Stream Binder :

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

Coder l’application

Procédez comme suit pour configurer votre application pour produire et consommer des messages à l’aide d’Azure Event Hubs.

  1. Configurez les informations d’identification event hub en ajoutant les propriétés suivantes à votre fichier 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
    

    Le tableau suivant décrit les champs de la configuration :

    Champ Description
    spring.cloud.azure.eventhubs.namespace Spécifiez l’espace de noms que vous avez obtenu dans votre event Hub à partir du Portail Azure.
    spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name Spécifiez le compte de stockage que vous avez créé dans ce tutoriel.
    spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name Spécifiez le conteneur de votre compte de stockage.
    spring.cloud.stream.bindings.consume-in-0.destination Spécifiez le hub d’événements que vous avez utilisé dans ce didacticiel.
    spring.cloud.stream.bindings.consume-in-0.group Spécifiez les groupes de consommateurs de votre instance Event Hubs.
    spring.cloud.stream.bindings.supply-out-0.destination Spécifiez le même hub d’événements que celui que vous avez utilisé dans ce tutoriel.
    spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode Spécifier MANUAL.
    spring.cloud.function.definition Spécifiez le composant Bean fonctionnel à lier aux destinations externes qui sont exposées par les liaisons.
    spring.cloud.stream.poller.initial-delay Spécifiez le délai initial pour les déclencheurs périodiques. La valeur par défaut est 0.
    spring.cloud.stream.poller.fixed-delay Spécifiez un délai fixe pour l’polleur par défaut en millisecondes. La valeur par défaut est 1 000 L.
  2. Modifiez le fichier de classe de démarrage pour afficher le contenu suivant.

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

    Conseil

    Dans ce tutoriel, il n’existe aucune opération d’authentification dans les configurations ou le code. Toutefois, la connexion aux services Azure nécessite une authentification. Pour effectuer l’authentification, vous devez utiliser Identité Azure. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque d’identités Azure fournit pour vous aider à obtenir des informations d’identification sans aucune modification du code.

    DefaultAzureCredential prend en charge plusieurs méthodes d’authentification et détermine quelle méthode doit être utilisée au moment de l’exécution. Cette approche permet à votre application d’utiliser différentes méthodes d’authentification dans différents environnements (tels que les environnements locaux et de production) sans implémenter de code spécifique à l’environnement. Pour plus d’informations, consultez DefaultAzureCredential.

    Pour terminer l’authentification dans les environnements de développement locaux, vous pouvez utiliser Azure CLI, Visual Studio Code, PowerShell ou d’autres méthodes. Pour plus d’informations, consultez l’authentification Azure dans les environnements de développement Java. Pour terminer l’authentification dans les environnements d’hébergement Azure, nous vous recommandons d’utiliser l’identité managée affectée par l’utilisateur. Pour plus d’informations, consultez Que sont les identités managées pour les ressources Azure ?

  3. Lancez l’application. Les messages tels que ceux-ci seront publiés dans le journal de votre application, comme illustré dans l’exemple de sortie suivant :

    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
    

Déployer sur Azure Spring Apps

Maintenant que vous disposez de l’application Spring Boot en cours d’exécution localement, il est temps de le déplacer en production. Azure Spring Apps facilite le déploiement d’applications Spring Boot sur Azure sans aucune modification de code. Le service gère l’infrastructure des applications Spring, ce qui permet aux développeurs de se concentrer sur leur code. Azure Spring Apps assure la gestion du cycle de vie en utilisant des outils complets, tels que la supervision et les diagnostics, la gestion des configurations, la découverte de services, l’intégration CI/CD, les déploiements bleus-verts, etc. Pour déployer votre application sur Azure Spring Apps, consultez Déployer votre première application sur Azure Spring Apps.

Étapes suivantes