Spring Cloud Stream med Azure Event Hubs

Artikel
01/18/2024

Den här självstudien visar hur du skickar och tar emot meddelanden med hjälp av Azure Event Hubs och Spring Cloud Stream Binder Eventhubs i ett Spring Boot-program.

Förutsättningar

En Azure-prenumeration – skapa en kostnadsfritt.
Java Development Kit (JDK) version 8 eller senare.
Apache Maven, version 3.2 eller senare.
cURL eller ett liknande HTTP-verktyg för att testa funktioner.
En Azure Event Hub. Om du inte har en skapar du en händelsehubb med Azure Portal.
Ett Azure Storage-konto för kontrollpunkter för händelsehubben. Om du inte har ett skapar du ett lagringskonto.
Ett Spring Boot-program. Om du inte har ett skapar du ett Maven-projekt med Spring Initializr. Se till att välja Maven Project och under Beroenden lägger du till Beroenden för Spring Web och Azure Support och väljer sedan Java version 8 eller senare.

Kommentar

Om du vill ge ditt konto åtkomst till resurser i Azure Event Hubs tilldelar Azure Event Hubs Data Receiver du rollen och Azure Event Hubs Data Sender till det Microsoft Entra-konto som du använder för närvarande. I Azure Storage-kontot tilldelar du Storage Blob Data Contributor sedan rollen till det Microsoft Entra-konto som du använder för närvarande. Mer information om hur du beviljar åtkomstroller finns i Tilldela Azure-roller med hjälp av Azure Portal och Auktorisera åtkomst till Event Hubs-resurser med hjälp av Microsoft Entra-ID.

Viktigt!

Spring Boot version 2.5 eller senare krävs för att slutföra stegen i den här självstudien.

Skicka och ta emot meddelanden från Azure Event Hubs

Med ett Azure Storage-konto och en Azure Event Hub kan du skicka och ta emot meddelanden med Spring Cloud Azure Stream Binder Event Hubs.

Om du vill installera Spring Cloud Azure Stream Binder Event Hubs-modulen lägger du till följande beroenden i din pom.xml-fil :

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

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> din pom.xml-fil . Detta säkerställer att alla Spring Cloud Azure-beroenden använder samma version. Mer information om vilken version som används för den här strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Spring Cloud Azure Stream Binder Event Hubs-artefakten:

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

Koda appen

Använd följande steg för att konfigurera ditt program för att producera och använda meddelanden med Hjälp av Azure Event Hubs.

Konfigurera autentiseringsuppgifterna för händelsehubben genom att lägga till följande egenskaper i filen 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

I följande tabell beskrivs fälten i konfigurationen:

Fält	beskrivning
`spring.cloud.azure.eventhubs.namespace`	Ange det namnområde som du fick i händelsehubben från Azure Portal.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name`	Ange det lagringskonto som du skapade i den här självstudien.
`spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name`	Ange containern för ditt lagringskonto.
`spring.cloud.stream.bindings.consume-in-0.destination`	Ange den händelsehubb som du använde i den här självstudien.
`spring.cloud.stream.bindings.consume-in-0.group`	Ange konsumentgrupper i din Event Hubs-instans.
`spring.cloud.stream.bindings.supply-out-0.destination`	Ange samma händelsehubb som du använde i den här självstudien.
`spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode`	Ange `MANUAL`.
`spring.cloud.function.definition`	Ange vilken funktionell böna som ska bindas till de externa mål som exponeras av bindningarna.
`spring.cloud.stream.poller.initial-delay`	Ange inledande fördröjning för periodiska utlösare. Standardvärdet är 0.
`spring.cloud.stream.poller.fixed-delay`	Ange en fast fördröjning för standardsökaren i millisekunder. Standardvärdet är 1 000 L.

Redigera startklassfilen för att visa följande innehåll.

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

}

Dricks

I den här självstudien finns det inga autentiseringsåtgärder i konfigurationerna eller koden. Att ansluta till Azure-tjänster kräver dock autentisering. För att slutföra autentiseringen måste du använda Azure Identity. Spring Cloud Azure använder DefaultAzureCredential, som Azure Identity-biblioteket tillhandahåller för att hjälpa dig att få autentiseringsuppgifter utan några kodändringar.

DefaultAzureCredential stöder flera autentiseringsmetoder och avgör vilken metod som ska användas vid körning. Med den här metoden kan din app använda olika autentiseringsmetoder i olika miljöer (till exempel lokala miljöer och produktionsmiljöer) utan att implementera miljöspecifik kod. Mer information finns i DefaultAzureCredential.

För att slutföra autentiseringen i lokala utvecklingsmiljöer kan du använda Azure CLI, Visual Studio Code, PowerShell eller andra metoder. Mer information finns i Azure-autentisering i Java-utvecklingsmiljöer. För att slutföra autentiseringen i Azure-värdmiljöer rekommenderar vi att du använder användartilldelad hanterad identitet. Mer information finns i Vad är hanterade identiteter för Azure-resurser?

Starta programmet. Meddelanden som detta publiceras i programloggen enligt följande exempelutdata:

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

Distribuera till Azure Spring Apps

Nu när Spring Boot-programmet körs lokalt är det dags att flytta det till produktion. Azure Spring Apps gör det enkelt att distribuera Spring Boot-program till Azure utan några kodändringar. Tjänsten hanterar infrastrukturen för Spring-program så att utvecklare kan fokusera på sin kod. Azure Spring Apps tillhandahåller livscykelhantering med omfattande övervakning och diagnostik, konfigurationshantering, tjänstidentifiering, CI/CD-integrering, blågröna distributioner med mera. Information om hur du distribuerar ditt program till Azure Spring Apps finns i Distribuera ditt första program till Azure Spring Apps.

Nästa steg

Azure for Spring-utvecklare Spring Cloud Azure Stream Binder Event Hubs-exempel

Dela via