Java를 사용 하 여 Azure에서 이벤트를 보내거나 이벤트를 수신 Event HubsUse Java to send events to or receive events from Azure Event Hubs

이 자습서에서는 Azure Event Hubs에 이벤트를 보내거나 이벤트를 수신 하는 Java 응용 프로그램을 만드는 방법을 보여 줍니다.This tutorial shows how to create Java applications to send events to or receive events from Azure Event Hubs.

Azure Event Hubs는 초당 수백만 개의 이벤트를 수신하여 처리할 수 있는 빅 데이터 스트리밍 플랫폼이자 이벤트 수집 서비스입니다.Azure Event Hubs is a Big Data streaming platform and event ingestion service, capable of receiving and processing millions of events per second. Event Hubs는 분산된 소프트웨어와 디바이스에서 생성된 이벤트, 데이터 또는 원격 분석을 처리하고 저장할 수 있습니다.Event Hubs can process and store events, data, or telemetry produced by distributed software and devices. 이벤트 허브로 전송된 데이터는 실시간 분석 공급자 또는 일괄 처리/스토리지 어댑터를 사용하여 변환하고 저장할 수 있습니다.Data sent to an event hub can be transformed and stored using any real-time analytics provider or batching/storage adapters. Event Hubs에 대 한 자세한 개요는 Event Hubs 개요 및 Event Hubs 기능을 참조 하세요.For detailed overview of Event Hubs, see Event Hubs overview and Event Hubs features.

참고

GitHub에서 샘플로 이 빠른 시작을 다운로드하여 EventHubConnectionStringEventHubName 문자열을 이벤트 허브 값으로 대체하고, 실행합니다.You can download this quickstart as a sample from the GitHub, replace EventHubConnectionString and EventHubName strings with your event hub values, and run it. 또는 이 자습서의 단계를 수행하여 직접 만들 수 있습니다.Alternatively, you can follow the steps in this tutorial to create your own.

전제 조건Prerequisites

이 자습서를 완료하려면 다음 필수 구성 요소가 필요합니다.To complete this tutorial, you need the following prerequisites:

  • 활성 Azure 계정.An active Azure account. Azure 구독이 아직 없는 경우 시작하기 전에 무료 계정을 만듭니다.If you do not have an Azure subscription, create a free account before you begin.
  • Java 개발 환경.A Java development environment. 이 자습서에서는 Eclipse를 사용합니다.This tutorial uses Eclipse.
  • Event Hubs 네임 스페이스 및 이벤트 허브를 만듭니다.Create an Event Hubs namespace and an event hub. 첫 번째 단계에서는 Azure Portal을 사용하여 Event Hubs 형식의 네임스페이스를 만들고 애플리케이션에서 Event Hub와 통신하는 데 필요한 관리 자격 증명을 얻습니다.The first step is to use the Azure portal to create a namespace of type Event Hubs, and obtain the management credentials your application needs to communicate with the event hub. 네임스페이스 및 이벤트 허브를 만들려면 이 문서의 절차를 따릅니다.To create a namespace and an event hub, follow the procedure in this article. 그런 다음 문서: 연결 문자열 가져오기의 지침에 따라 이벤트 허브에 대 한 액세스 키의 값을 가져옵니다.Then, get the value of access key for the event hub by following instructions from the article: Get connection string. 액세스 키는 이 자습서의 뒷부분에서 작성하는 코드에 사용합니다.You use the access key in the code you write later in this tutorial. 기본 키 이름은 RootManageSharedAccessKey입니다.The default key name is: RootManageSharedAccessKey.

이벤트 보내기Send events

이 섹션에서는 이벤트 허브로 이벤트를 전송 하는 Java 응용 프로그램을 만드는 방법을 보여 줍니다.This section shows you how to create a Java application to send events an event hub.

Azure Event Hubs 라이브러리에 대한 참조 추가Add reference to Azure Event Hubs library

Event Hubs에 대한 Java 클라이언트 라이브러리는 Maven 중앙 리포지토리에서 Maven 프로젝트에 사용할 수 있습니다.The Java client library for Event Hubs is available for use in Maven projects from the Maven Central Repository. Maven 프로젝트 파일 안에 다음 종속성 선언을 사용하여 이 라이브러리를 참조할 수 있습니다.You can reference this library using the following dependency declaration inside your Maven project file:

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs</artifactId>
    <version>2.2.0</version>
</dependency>

다양한 형식의 빌드 환경을 위해, Maven 중앙 리포지토리에서 최근에 릴리스된 JAR 파일을 명시적으로 가져올 수 있습니다.For different types of build environments, you can explicitly obtain the latest released JAR files from the Maven Central Repository.

단순 이벤트 게시자의 경우 Event Hubs 클라이언트 클래스에 대한 com.microsoft.azure.eventhubs 패키지와 유틸리티 클래스(예: Azure Service Bus 메시징 클라이언트와 공유되는 일반적인 예외)에 대한 com.microsoft.azure.servicebus 패키지를 가져옵니다.For a simple event publisher, import the com.microsoft.azure.eventhubs package for the Event Hubs client classes and the com.microsoft.azure.servicebus package for utility classes such as common exceptions that are shared with the Azure Service Bus messaging client.

이벤트 허브에 메시지를 전송하는 코드 작성Write code to send messages to the event hub

다음 샘플에서는 먼저 즐겨 찾는 Java 개발 환경에서 콘솔/셸 애플리케이션에 대한 새 Maven 프로젝트를 만듭니다.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. SimpleSend 클래스를 추가하고 해당 클래스에 다음 코드를 추가합니다.Add a class named SimpleSend, and add the following code to the class:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.microsoft.azure.eventhubs.ConnectionStringBuilder;
import com.microsoft.azure.eventhubs.EventData;
import com.microsoft.azure.eventhubs.EventHubClient;
import com.microsoft.azure.eventhubs.EventHubException;

import java.io.IOException;
import java.nio.charset.Charset;
import java.time.Instant;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class SimpleSend {

    public static void main(String[] args)
            throws EventHubException, ExecutionException, InterruptedException, IOException {
            
            
    }
 }

연결 문자열 생성Construct connection string

ConnectionStringBuilder 클래스를 사용하여 Event Hubs 클라이언트 인스턴스로 전달하는 연결 문자열 값을 생성합니다.Use the ConnectionStringBuilder class to construct a connection string value to pass to the Event Hubs client instance. 자리 표시자를 네임스페이스 및 이벤트 허브를 만들 때 얻은 값으로 바꿉니다.Replace the placeholders with the values you obtained when you created the namespace and event hub:

        final ConnectionStringBuilder connStr = new ConnectionStringBuilder()
                .setNamespaceName("<EVENTHUB NAMESPACE") 
                .setEventHubName("EVENT HUB")
                .setSasKeyName("RootManageSharedAccessKey")
                .setSasKey("SHARED ACCESS KEY");

이벤트를 전송 하는 코드 작성Write code to send events

문자열을 UTF-8 바이트 인코딩으로 전환하여 단일 이벤트를 만듭니다.Create a singular event by transforming a string into its UTF-8 byte encoding. 그런 다음, 연결 문자열에서 새 Event Hubs 클라이언트 인스턴스를 만들고 메시지를 보냅니다.Then, create a new Event Hubs client instance from the connection string and send the message:

        final Gson gson = new GsonBuilder().create();

        // The Executor handles all asynchronous tasks and this is passed to the EventHubClient instance.
        // This enables the user to segregate their thread pool based on the work load.
        // This pool can then be shared across multiple EventHubClient instances.
        // The following sample uses a single thread executor, as there is only one EventHubClient instance,
        // handling different flavors of ingestion to Event Hubs here.
        final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);

        // Each EventHubClient instance spins up a new TCP/SSL connection, which is expensive.
        // It is always a best practice to reuse these instances. The following sample shows this.
        final EventHubClient ehClient = EventHubClient.createSync(connStr.toString(), executorService);


        try {
            for (int i = 0; i < 10; i++) {

                String payload = "Message " + Integer.toString(i);
                byte[] payloadBytes = gson.toJson(payload).getBytes(Charset.defaultCharset());
                EventData sendEvent = EventData.create(payloadBytes);

                // Send - not tied to any partition
                // Event Hubs service will round-robin the events across all Event Hubs partitions.
                // This is the recommended & most reliable way to send to Event Hubs.
                ehClient.sendSync(sendEvent);
            }

            System.out.println(Instant.now() + ": Send Complete...");
            System.out.println("Press Enter to stop.");
            System.in.read();
        } finally {
            ehClient.closeSync();
            executorService.shutdown();
        }

프로그램을 빌드 및 실행하고, 오류가 없는지 확인합니다.Build and run the program, and ensure that there are no errors.

축하합니다.Congratulations! 이제 Event Hub에 메시지를 보냈습니다.You have now sent messages to an event hub.

부록: 메시지가 EventHub 파티션으로 라우팅되는 방식Appendix: How messages are routed to EventHub partitions

소비자가 메시지를 검색할 수 있으려면 먼저 게시자가 파티션에 메시지를 게시해야 합니다.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. com.microsoft.azure.eventhubs.EventHubClient 개체에서 sendSync() 메서드를 사용하여 메시지를 이벤트 허브에 동기적으로 게시하면 파티션 키의 지정 여부에 따라 라운드 로빈 방식으로 메시지를 특정 파티션으로 보내거나 사용 가능한 모든 파티션에 분산할 수 있습니다.When messages are published to event hub synchronously using the sendSync() method on the com.microsoft.azure.eventhubs.EventHubClient object, the message could be sent to a specific partition or distributed to all available partitions in a round-robin manner depending on whether the partition key is specified or not.

파티션 키를 나타내는 문자열을 지정하면 이벤트로 보낼 파티션을 결정하기 위해 키가 해시됩니다.When a string representing the partition key is specified, the key will be hashed to determine which partition to send the event to.

파티션 키를 설정하지 않으면 사용 가능한 모든 파티션으로 메시지가 라운드 로빈됩니다.When the partition key is not set, then messages will round-robined to all available partitions

// Serialize the event into bytes
byte[] payloadBytes = gson.toJson(messagePayload).getBytes(Charset.defaultCharset());

// Use the bytes to construct an {@link EventData} object
EventData sendEvent = EventData.create(payloadBytes);

// Transmits the event to event hub without a partition key
// If a partition key is not set, then we will round-robin to all topic partitions
eventHubClient.sendSync(sendEvent);

//  the partitionKey will be hash'ed to determine the partitionId to send the eventData to.
eventHubClient.sendSync(sendEvent, partitionKey);

// close the client at the end of your program
eventHubClient.closeSync();

이벤트 수신Receive events

이 자습서의 코드는 전체 작동 중인 애플리케이션을 확인하기 위해 검사할 수 있는 GitHub의 EventProcessorSample 코드를 기반으로 합니다.The code in this tutorial is based on the EventProcessorSample code on GitHub, which you can examine to see the full working application.

Java에서 EventProcessorHost를 사용하여 메시지 수신Receive messages with EventProcessorHost in Java

EventProcessorHost는 영구적 검사점을 관리하여 Event Hubs의 이벤트 수신을 간소화하고 이러한 Event Hubs에서 병렬 수신하는 Java 클래스입니다.EventProcessorHost is a Java class that simplifies receiving events from Event Hubs by managing persistent checkpoints and parallel receives from those Event Hubs. EventProcessorHost를 사용하면 다른 노드에 호스트된 경우라도 여러 수신기 간에 이벤트를 분할할 수 있습니다.Using EventProcessorHost, you can split events across multiple receivers, even when hosted in different nodes. 이 예제에서는 단일 수신기에 대해 EventProcessorHost를 사용하는 방법을 보여 줍니다.This example shows how to use EventProcessorHost for a single receiver.

스토리지 계정 만들기Create a storage account

EventProcessorHost를 사용 하려면 [Azure Storage 계정] [Azure Storage 계정]이 있어야 합니다.To use EventProcessorHost, you must have an [Azure Storage account][Azure Storage account]:

  1. Azure Portal에 로그인 하 고 화면의 왼쪽에서 리소스 만들기 를 선택 합니다.Sign in the Azure portal, and select Create a resource on the left-hand side of the screen.

  2. 저장소를 선택 하 고 저장소 계정을 선택 합니다.Select Storage, then select Storage account. 스토리지 계정 만들기 창에서 스토리지 계정에 사용할 이름을 입력합니다.In the Create storage account window, type a name for the storage account. 나머지 필드를 완료 하 고 원하는 지역을 선택한 후 만들기를 선택 합니다.Complete the rest of the fields, select your desired region, and then select Create.

    Azure Portal에서 저장소 계정 만들기

  3. 새로 만든 저장소 계정을 선택 하 고 액세스 키를 선택 합니다.Select the newly created storage account, and then select Access Keys:

    Azure Portal에서 액세스 키 가져오기

    Key1 값을 임시 위치로 복사합니다.Copy the key1 value to a temporary location. 이 자습서의 뒷부분에서 사용합니다.You use it later in this tutorial.

EventProcessor 호스트를 사용하여 Java 프로젝트 만들기Create a Java project using the EventProcessor Host

이벤트 허브에 대한 Java 클라이언트 라이브러리는 Maven 중앙 리포지토리의 Maven 프로젝트에 사용할 수 있으며 Maven 프로젝트 파일 내의 다음 종속성 선언을 사용하여 참조할 수 있습니다.The Java client library for Event Hubs is available for use in Maven projects from the Maven Central Repository, and can be referenced using the following dependency declaration inside your Maven project file:

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs</artifactId>
    <version>2.2.0</version>
</dependency>
<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs-eph</artifactId>
    <version>2.4.0</version>
</dependency>

다양한 형식의 빌드 환경을 위해, Maven 중앙 리포지토리에서 최근에 릴리스된 JAR 파일을 명시적으로 가져올 수 있습니다.For different types of build environments, you can explicitly obtain the latest released JAR files from the Maven Central Repository.

  1. 다음 샘플에서는 먼저 즐겨 찾는 Java 개발 환경에서 콘솔/셸 애플리케이션에 대한 새 Maven 프로젝트를 만듭니다.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. 클래스는 ErrorNotificationHandler라고 합니다.The class is called ErrorNotificationHandler.

    import java.util.function.Consumer;
    import com.microsoft.azure.eventprocessorhost.ExceptionReceivedEventArgs;
    
    public class ErrorNotificationHandler implements Consumer<ExceptionReceivedEventArgs>
    {
        @Override
        public void accept(ExceptionReceivedEventArgs t)
        {
            System.out.println("SAMPLE: Host " + t.getHostname() + " received general error notification during " + t.getAction() + ": " + t.getException().toString());
        }
    }
    
  2. 다음 코드를 사용하여 EventProcessorSample(이)라는 클래스를 새로 만듭니다.Use the following code to create a new class called EventProcessorSample. 자리 표시자를 이벤트 허브 및 스토리지 계정을 만들 때 사용한 값으로 바꿉니다.Replace the placeholders with the values used when you created the event hub and storage account:

    package com.microsoft.azure.eventhubs.samples.eventprocessorsample;
    
    import com.microsoft.azure.eventhubs.ConnectionStringBuilder;
    import com.microsoft.azure.eventhubs.EventData;
    import com.microsoft.azure.eventprocessorhost.CloseReason;
    import com.microsoft.azure.eventprocessorhost.EventProcessorHost;
    import com.microsoft.azure.eventprocessorhost.EventProcessorOptions;
    import com.microsoft.azure.eventprocessorhost.ExceptionReceivedEventArgs;
    import com.microsoft.azure.eventprocessorhost.IEventProcessor;
    import com.microsoft.azure.eventprocessorhost.PartitionContext;
    
    import java.util.concurrent.ExecutionException;
    import java.util.function.Consumer;
    
    public class EventProcessorSample
    {
        public static void main(String args[]) throws InterruptedException, ExecutionException
        {
            String consumerGroupName = "$Default";
            String namespaceName = "----NamespaceName----";
            String eventHubName = "----EventHubName----";
            String sasKeyName = "----SharedAccessSignatureKeyName----";
            String sasKey = "----SharedAccessSignatureKey----";
            String storageConnectionString = "----AzureStorageConnectionString----";
            String storageContainerName = "----StorageContainerName----";
            String hostNamePrefix = "----HostNamePrefix----";
    
            ConnectionStringBuilder eventHubConnectionString = new ConnectionStringBuilder()
                 .setNamespaceName(namespaceName)
                 .setEventHubName(eventHubName)
                 .setSasKeyName(sasKeyName)
                 .setSasKey(sasKey);
    
            EventProcessorHost host = new EventProcessorHost(
                 EventProcessorHost.createHostName(hostNamePrefix),
                 eventHubName,
                 consumerGroupName,
                 eventHubConnectionString.toString(),
                 storageConnectionString,
                 storageContainerName);
    
            System.out.println("Registering host named " + host.getHostName());
            EventProcessorOptions options = new EventProcessorOptions();
            options.setExceptionNotification(new ErrorNotificationHandler());
    
            host.registerEventProcessor(EventProcessor.class, options)
            .whenComplete((unused, e) ->
            {
                if (e != null)
                {
                    System.out.println("Failure while registering: " + e.toString());
                    if (e.getCause() != null)
                    {
                        System.out.println("Inner exception: " + e.getCause().toString());
                    }
                }
            })
            .thenAccept((unused) ->
            {
                System.out.println("Press enter to stop.");
                try 
                {
                    System.in.read();
                }
                catch (Exception e)
                {
                    System.out.println("Keyboard read failed: " + e.toString());
                }
            })
            .thenCompose((unused) ->
            {
                return host.unregisterEventProcessor();
            })
            .exceptionally((e) ->
            {
                System.out.println("Failure while unregistering: " + e.toString());
                if (e.getCause() != null)
                {
                    System.out.println("Inner exception: " + e.getCause().toString());
                }
                return null;
            })
            .get(); // Wait for everything to finish before exiting main!
    
            System.out.println("End of sample");
        }
    
  3. 다음 코드를 사용하여 EventProcessor라는 클래스를 하나 이상 만듭니다.Create one more class called EventProcessor, using the following code:

    public static class EventProcessor implements IEventProcessor
    {
        private int checkpointBatchingCount = 0;
    
        // OnOpen is called when a new event processor instance is created by the host. 
        @Override
        public void onOpen(PartitionContext context) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " is opening");
        }
    
        // OnClose is called when an event processor instance is being shut down. 
        @Override
        public void onClose(PartitionContext context, CloseReason reason) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " is closing for reason " + reason.toString());
        }
    
        // onError is called when an error occurs in EventProcessorHost code that is tied to this partition, such as a receiver failure.
        @Override
        public void onError(PartitionContext context, Throwable error)
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " onError: " + error.toString());
        }
    
        // onEvents is called when events are received on this partition of the Event Hub. 
        @Override
        public void onEvents(PartitionContext context, Iterable<EventData> events) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " got event batch");
            int eventCount = 0;
            for (EventData data : events)
            {
                try
                {
                    System.out.println("SAMPLE (" + context.getPartitionId() + "," + data.getSystemProperties().getOffset() + "," +
                            data.getSystemProperties().getSequenceNumber() + "): " + new String(data.getBytes(), "UTF8"));
                    eventCount++;
    
                    // Checkpointing persists the current position in the event stream for this partition and means that the next
                    // time any host opens an event processor on this event hub+consumer group+partition combination, it will start
                    // receiving at the event after this one. 
                    this.checkpointBatchingCount++;
                    if ((checkpointBatchingCount % 5) == 0)
                    {
                        System.out.println("SAMPLE: Partition " + context.getPartitionId() + " checkpointing at " +
                            data.getSystemProperties().getOffset() + "," + data.getSystemProperties().getSequenceNumber());
                        // Checkpoints are created asynchronously. It is important to wait for the result of checkpointing
                        // before exiting onEvents or before creating the next checkpoint, to detect errors and to ensure proper ordering.
                        context.checkpoint(data).get();
                    }
                }
                catch (Exception e)
                {
                    System.out.println("Processing failed for an event: " + e.toString());
                }
            }
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " batch size was " + eventCount + " for host " + context.getOwner());
        }
    }
    

이 자습서에서는 EventProcessorHost의 단일 인스턴스를 사용합니다.This tutorial uses a single instance of EventProcessorHost. 처리량을 늘리려면 EventProcessorHost의 여러 인스턴스를 개별 머신에서 실행하는 것이 좋습니다.To increase throughput, we recommend that you run multiple instances of EventProcessorHost, preferably on separate machines. 그러면 중복성도 함께 제공됩니다.It provides redundancy as well. 이러한 경우 다양한 인스턴스가 자동으로 서로 조정하여 수신된 이벤트의 부하를 분산합니다.In those cases, the various instances automatically coordinate with each other in order to load balance the received events. 여러 수신기가 각각 이벤트를 모두 처리하도록 하려면 ConsumerGroup 개념을 사용해야 합니다.If you want multiple receivers to each process all the events, you must use the ConsumerGroup concept. 서로 다른 컴퓨터에서 이벤트를 수신하는 경우 EventProcessorHost 인스턴스의 이름을 해당 인스턴스가 배포된 컴퓨터 또는 역할을 기준으로 지정하면 유용할 수 있습니다.When receiving events from different machines, it might be useful to specify names for EventProcessorHost instances based on the machines (or roles) in which they are deployed.

EventHub에 메시지 게시Publishing Messages to EventHub

소비자가 메시지를 검색할 수 있으려면 먼저 게시자가 파티션에 메시지를 게시해야 합니다.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. com.microsoft.azure.eventhubs.EventHubClient 개체에서 sendSync() 메서드를 사용하여 메시지를 이벤트 허브에 동기적으로 게시하면 파티션 키의 지정 여부에 따라 라운드 로빈 방식으로 메시지를 특정 파티션으로 보내거나 사용 가능한 모든 파티션에 분산할 수 있다는 점이 중요합니다.It is worth noting that when messages are published to event hub synchronously using the sendSync() method on the com.microsoft.azure.eventhubs.EventHubClient object, the message could be sent to a specific partition or distributed to all available partitions in a round-robin manner depending on whether the partition key is specified or not.

파티션 키를 나타내는 문자열이 지정되면 이벤트로 보낼 파티션을 결정하기 위해 키가 해시됩니다.When a string representing the partition key is specified, the key is hashed to determine which partition to send the event to.

파티션 키를 설정하지 않으면 사용 가능한 모든 파티션으로 메시지가 라운드 로빈됩니다.When the partition key is not set, then messages are round-robined to all available partitions

// Serialize the event into bytes
byte[] payloadBytes = gson.toJson(messagePayload).getBytes(Charset.defaultCharset());

// Use the bytes to construct an {@link EventData} object
EventData sendEvent = EventData.create(payloadBytes);

// Transmits the event to event hub without a partition key
// If a partition key is not set, then we will round-robin to all topic partitions
eventHubClient.sendSync(sendEvent);

//  the partitionKey will be hash'ed to determine the partitionId to send the eventData to.
eventHubClient.sendSync(sendEvent, partitionKey);

EventProcessorHost(EPH)에 대한 사용자 지정 CheckpointManager 구현Implementing a Custom CheckpointManager for EventProcessorHost (EPH)

API는 기본 구현이 사용 사례와 호환되지 않는 시나리오를 위해 사용자 지정 검사점 관리자를 구현하는 메커니즘을 제공합니다.The API provides a mechanism to implement your custom checkpoint manager for scenarios where the default implementation is not compatible with your use case.

기본 검사점 관리자는 Blob Storage를 사용하지만, EPH에서 사용하는 검사점 관리자를 사용자 고유의 구현으로 재정의하는 경우 원하는 스토리지를 사용하여 검사점 관리자 구현을 지원할 수 있습니다.The default checkpoint manager uses blob storage but if you override the checkpoint manager used by EPH with your own implementation, you can use any store you want to back your checkpoint manager implementation.

com.microsoft.azure.eventprocessorhost.ICheckpointManager 인터페이스를 구현하는 클래스를 만듭니다.Create a class that implements the interface com.microsoft.azure.eventprocessorhost.ICheckpointManager

사용자 지정 검사점 관리자(com.microsoft.azure.eventprocessorhost.ICheckpointManager) 구현 사용Use your custom implementation of the checkpoint manager (com.microsoft.azure.eventprocessorhost.ICheckpointManager)

구현 내에서 기본 검사점 메커니즘을 재정의 하 고 사용자 고유의 데이터 저장소 (예: SQL Server, CosmosDB 및 Redis 용 Azure Cache)를 기반으로 사용자 고유의 검사점을 구현할 수 있습니다.Within your implementation, you can override the default checkpointing mechanism and implement our own checkpoints based on your own data store (like SQL Server, CosmosDB, and Azure Cache for Redis). 소비자 그룹의 이벤트를 처리하는 모든 EPH 인스턴스가 검사점 관리자 구현을 지원하는 데 사용된 저장소에 액세스할 수 있도록 하는 것이 좋습니다.We recommend that the store used to back your checkpoint manager implementation is accessible to all EPH instances that are processing events for the consumer group.

사용자 환경에 제공되는 모든 데이터 저장소를 사용할 수 있습니다.You can use any datastore that is available in your environment.

com.microsoft.azure.eventprocessorhost.EventProcessorHost 클래스는 EventProcessorHost의 검사점 관리자를 재정의할 수 있는 2가지 생성자를 제공합니다.The com.microsoft.azure.eventprocessorhost.EventProcessorHost class provides you with two constructors that allow you to override the checkpoint manager for your EventProcessorHost.

다음 단계Next steps

다음 문서를 읽어보세요.Read the following articles: