Spring Cloud Stream mit Azure Event Hubs

Artikel
10/04/2024

In diesem Lernprogramm wird das Senden und Empfangen von Nachrichten mithilfe von Azure Event Hubs und Spring Cloud Stream Binder Eventhubs in einer Spring Boot-Anwendung veranschaulicht.

Voraussetzungen

Azure-Abonnement (kostenloses Abonnement erstellen)
Java Development Kit (JDK) Version 8 oder höher.
Apache Maven Version 3.2 oder höher.
cURL oder ein ähnliches HTTP-Hilfsprogramm zum Testen der Funktionalität.
Ein Azure Event Hub. Wenn Sie keine haben, erstellen Sie einen Event-Hub mit dem Azure-Portal.
Ein Azure Storage Account für Event Hub-Prüfpunkte. Erstellen Sie ein Speicherkonto, falls Sie noch keines besitzen.
Ein Spring Boot-Anwendung. Wenn Sie keine Spring Boot-Anwendung besitzen, erstellen Sie mit Spring Initializr ein Maven-Projekt. Achten Sie darauf, Maven-Projekt auszuwählen, fügen Sie unter Abhängigkeiten die Abhängigkeit Spring Web und Azure-Support hinzu, und wählen Sie dann Java-Version 8 oder höher aus.

Hinweis

Um Ihrem Konto Zugriff auf Ressourcen zu gewähren, weisen Sie in Azure Event Hubs die Rolle Azure Event Hubs Data Receiver und die Rolle Azure Event Hubs Data Sender dem Microsoft Entra-Konto zu, das Sie derzeit verwenden. Weisen Sie dann im Azure Storage-Konto die Rolle Storage Blob Data Contributor dem Microsoft Entra-Konto zu, das Sie derzeit verwenden. Weitere Informationen zum Gewähren von Zugriffsrollen finden Sie unter Zuweisen von Azure-Rollen mithilfe der Azure-Portal und Autorisieren des Zugriffs auf Event Hubs-Ressourcen mithilfe der Microsoft Entra-ID.

Wichtig

Für die Schritte in diesem Tutorial wird mindestens die Spring Boot-Version 2.5 benötigt.

Senden und Empfangen von Nachrichten von Azure Event Hubs

Mit einem Azure Storage-Konto und einem Azure Event Hub können Sie Nachrichten mithilfe von Spring Cloud Azure Stream Binder Event Hubs senden und empfangen.

Um das Spring Cloud Azure Stream Binder Event Hubs-Modul zu installieren, fügen Sie Ihrer pom.xml-Datei die folgenden Abhängigkeiten hinzu:

Die Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>5.19.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```
Hinweis

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.19.0 festlegen. Diese Stückliste (Bill of Material, BOM) sollte im <dependencyManagement> Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der Version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Das Spring Cloud Azure Stream Binder Event Hubs Artefakt:

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

Codieren der Anwendung

Führen Sie die folgenden Schritte aus, um Ihre Anwendung so zu konfigurieren, dass Nachrichten mithilfe von Azure Event Hubs erstellt und genutzt werden.

Konfigurieren Sie die Event Hub-Anmeldeinformationen, indem Sie der Datei application.properties die folgenden Eigenschaften hinzufügen.

 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

In der folgenden Tabelle werden die Felder der Konfiguration beschrieben:

Feld	Beschreibung
`spring.cloud.azure.eventhubs.namespace`	Geben Sie den Namespace an, die Sie im Event Hub vom Azure-Portal erhalten haben.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name`	Geben Sie das in diesem Tutorial erstellte Speicherkonto an.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name`	Geben Sie den Container Ihres Speicherkontos an.
`spring.cloud.stream.bindings.consume-in-0.destination`	Geben Sie die in diesem Tutorial verwendete Event Hub-Instanz an.
`spring.cloud.stream.bindings.consume-in-0.group`	Geben Sie die Consumergruppen in der Event Hubs-Instanz an.
`spring.cloud.stream.bindings.supply-out-0.destination`	Geben Sie die Event Hub-Instanz an, die Sie auch in diesem Tutorial verwendet haben.
`spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode`	Geben Sie `MANUAL` an.
`spring.cloud.function.definition`	Geben Sie an, welches funktionale Bean an die externen Ziele gebunden werden soll, die von den Bindungen verfügbar gemacht werden.
`spring.cloud.stream.poller.initial-delay`	Geben Sie die anfängliche Verzögerung für regelmäßige Trigger an. Der Standardwert ist 0.
`spring.cloud.stream.poller.fixed-delay`	Geben Sie eine feste Verzögerung für den Standard-Poller in Millisekunden an. Der Standardwert ist 1000 L.

Bearbeiten Sie die Startklassendatei, um den folgenden Inhalt anzuzeigen.

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

}

Tipp

In diesem Lernprogramm gibt es keine Authentifizierungsvorgänge in den Konfigurationen oder im Code. Für die Verbindung mit dem Azure-Diensten ist jedoch eine Authentifizierung erforderlich. Um die Authentifizierung abzuschließen, müssen Sie Azure Identity verwenden. Spring Cloud Azure verwendet DefaultAzureCredential, was die Azure Identity-Bibliothek bereitstellt, um Sie beim Abrufen von Anmeldeinformationen ohne Codeänderungen zu unterstützen.

„DefaultAzureCredential“ unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet wird. Mit diesem Ansatz kann Ihre Anwendung verschiedene Authentifizierungsmethoden in unterschiedlichen Umgebungen verwenden (z. B. in lokalen oder Produktionsumgebungen), ohne dass umgebungsspezifischer Code implementiert werden muss. Weitere Informationen finden Sie unter DefaultAzureCredential.

Um die Authentifizierung in lokalen Entwicklungsumgebungen abzuschließen, können Sie Azure CLI, Visual Studio Code, PowerShell oder andere Methoden verwenden. Weitere Informationen finden Sie unter Azure-Authentifizierung in Java-Entwicklungsumgebungen. Um die Authentifizierung in Azure-Hostingumgebungen abzuschließen, empfehlen wir die Verwendung einer benutzerzugewiesenen verwalteten Identität. Weitere Informationen finden Sie unter Was sind verwaltete Identitäten für Azure-Ressourcen?.

Starten Sie die Anwendung. Nachrichten wie diese werden in Ihrem Anwendungsprotokoll gepostet, wie in der folgenden Beispielausgabe gezeigt:

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

Bereitstellen in Azure Spring Apps

Nachdem Sie nun die Spring Boot-Anwendung lokal ausgeführt haben, ist es an der Zeit, sie in die Produktion zu verschieben. Mit Azure Spring Apps lassen sich Spring Boot-Anwendungen ganz einfach und ohne Codeänderungen in Azure bereitstellen. Der Dienst verwaltet die Infrastruktur von Spring-Anwendungen und ermöglicht es Entwicklern dadurch, sich auf ihren Code zu konzentrieren. Azure Spring Apps bietet eine Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, Blau/Grün-Bereitstellungen und mehr. Informationen zum Bereitstellen Ihrer Anwendung in Azure Spring Apps finden Sie unter Bereitstellen Ihrer ersten Anwendung in Azure Spring Apps.

Nächste Schritte

Azure für Spring Entwickler Beispiele für Spring Cloud Azure Stream Binder Event Hubs

Freigeben über