Envío o recepción de eventos en Azure Event Hubs mediante JavaSend events to or receive events from Azure Event Hubs using Java

Azure Event Hubs es una plataforma de streaming de macrodatos y servicio de ingesta de eventos de gran escalabilidad capaz de recibir y procesar millones de eventos por segundo.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 puede procesar y almacenar eventos, datos o telemetría generados por dispositivos y software distribuido.Event Hubs can process and store events, data, or telemetry produced by distributed software and devices. Los datos enviados a un centro de eventos se pueden transformar y almacenar con cualquier proveedor de análisis en tiempo real o adaptadores de procesamiento por lotes y almacenamiento.Data sent to an event hub can be transformed and stored using any real-time analytics provider or batching/storage adapters. Para más información sobre Event Hubs, consulte Introducción a Event Hubs y Características de Event Hubs.For detailed overview of Event Hubs, see Event Hubs overview and Event Hubs features.

En este tutorial se muestra cómo crear aplicaciones de Java para enviar y recibir eventos en un centro de eventos.This tutorial shows how to create Java applications to send events to or receive events from an event hub.

Nota

Puede descargar esta guía de inicio rápido como un ejemplo desde GitHub, reemplazar las cadenas EventHubConnectionString y EventHubName por los valores del centro de eventos, y ejecutarlo.You can download this quickstart as a sample from the GitHub, replace EventHubConnectionString and EventHubName strings with your event hub values, and run it. También puede seguir los pasos de este tutorial para crear el suyo propio.Alternatively, you can follow the steps in this tutorial to create your own.

Requisitos previosPrerequisites

Para completar este tutorial, debe cumplir los siguientes requisitos previos:To complete this tutorial, you need the following prerequisites:

  • Una cuenta de Azure activa.An active Azure account. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.If you do not have an Azure subscription, create a free account before you begin.
  • Un entorno de desarrollo de Java.A Java development environment. En este tutorial se usa Eclipse.This tutorial uses Eclipse.
  • Creación de un espacio de nombres de Event Hubs y un centro de eventos.Create an Event Hubs namespace and an event hub. El primer paso consiste en usar Azure Portal para crear un espacio de nombres de tipo Event Hubs y obtener las credenciales de administración que la aplicación necesita para comunicarse con el centro de eventos.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. Para crear un espacio de nombres y un centro de eventos, siga el procedimiento que se indica en este artículo.To create a namespace and an event hub, follow the procedure in this article. Luego, para obtener el valor de la clave de acceso del centro de eventos, siga las instrucciones del artículo: Obtenga la cadena de conexión.Then, get the value of access key for the event hub by following instructions from the article: Get connection string. Utilice la clave de acceso en el código que escriba más adelante en este tutorial.You use the access key in the code you write later in this tutorial. El nombre de la clave predeterminada es: RootManageSharedAccessKey.The default key name is: RootManageSharedAccessKey.

Envío de eventosSend events

En esta sección se muestra cómo crear una aplicación de Java para enviar eventos a un centro de eventos.This section shows you how to create a Java application to send events an event hub.

Incorporación de una referencia a la biblioteca de Azure Event HubsAdd reference to Azure Event Hubs library

La biblioteca de cliente de Java para Event Hubs está disponible para su uso en proyectos de Maven desde el repositorio central de Maven.The Java client library for Event Hubs is available for use in Maven projects from the Maven Central Repository. Puede hacer referencia a esta biblioteca con la siguiente declaración de dependencia en el archivo de proyecto de 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>

Para distintos tipos de entornos de compilación, puede obtener explícitamente los últimos archivos JAR publicados del repositorio central de Maven.For different types of build environments, you can explicitly obtain the latest released JAR files from the Maven Central Repository.

Para un editor de eventos simples, importe el paquete com.microsoft.azure.eventhubs para las clases de cliente de Event Hubs y el paquete com.microsoft.azure.servicebus para las clases de utilidad, como las excepciones comunes que se comparten con el cliente de mensajería de Azure Service Bus.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.

Escritura de código para enviar mensajes al centro de eventosWrite code to send messages to the event hub

Para el ejemplo siguiente, primero cree un nuevo proyecto de Maven para una aplicación de consola o shell en su entorno de desarrollo de Java favorito.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. Agregue una clase denominada SimpleSend y agréguele el código siguiente: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 {
            
            
    }
 }

Crear cadena de conexiónConstruct connection string

Use la clase ConnectionStringBuilder para construir un valor de cadena de conexión y pasarlo a la instancia de cliente de Event Hubs.Use the ConnectionStringBuilder class to construct a connection string value to pass to the Event Hubs client instance. Reemplace los marcadores de posición por los valores que obtuvo al crear el espacio de nombres y el centro de eventos:Replace the placeholders with the values you obtained when you created the namespace and event hub:

        final ConnectionStringBuilder connStr = new ConnectionStringBuilder()
                .setNamespaceName("speventhubns") 
                .setEventHubName("speventhub")
                .setSasKeyName("RootManageSharedAccessKey")
                .setSasKey("2+WMsyyy1XmUtEnRsfOmTTyGasfJgsVjGAOIN20J1Y8=");

Escritura de código para enviar eventosWrite code to send events

Cree un evento singular transformando una cadena en su codificación de bytes UTF-8.Create a singular event by transforming a string into its UTF-8 byte encoding. Después cree una instancia de cliente de Event Hubs a partir de la cadena de conexión y envíe el mensaje: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();
        }

Compile y ejecute el programa y asegúrese de que no haya errores.Build and run the program, and ensure that there are no errors.

Felicidades.Congratulations! Ha enviado mensajes a un centro de eventos.You have now sent messages to an event hub.

Apéndice: Cómo se enrutan los mensajes a las particiones de EventHubAppendix: How messages are routed to EventHub partitions

Antes de que los consumidores puedan recuperar los mensajes, los editores tienen que publicarlos primero en las particiones.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. Cuando los mensajes se publican en el centro de eventos de manera sincrónica con el método sendSync() en el objeto com.microsoft.azure.eventhubs.EventHubClient, se pueden enviar a una partición específica o distribuirse a todas las particiones disponibles en modo round-robin, según si se especifica o no la clave de partición.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.

Cuando se especifica una cadena que representa la clave de partición, se aplicará un algoritmo hash a la clave para determinar la partición a la que desea enviar el evento.When a string representing the partition key is specified, the key will be hashed to determine which partition to send the event to.

Cuando no se establece la clave de partición, los mensajes se envían en modo round-robin a todas las particiones disponiblesWhen 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();

Recepción de eventosReceive events

El código de este tutorial se basa en el código EventProcessorSample en GitHub, que se puede examinar para ver toda la aplicación en funcionamiento.The code in this tutorial is based on the EventProcessorSample code on GitHub, which you can examine to see the full working application.

Recepción de mensajes con EventProcessorHost en JavaReceive messages with EventProcessorHost in Java

EventProcessorHost es una clase de Java que simplifica la recepción de eventos desde Event Hubs mediante la administración de puntos de control persistentes y recepciones paralelas desde tales Centros de eventos.EventProcessorHost is a Java class that simplifies receiving events from Event Hubs by managing persistent checkpoints and parallel receives from those Event Hubs. Con EventProcessorHost, puede dividir eventos entre varios destinatarios, incluso cuando están hospedados en distintos nodos.Using EventProcessorHost, you can split events across multiple receivers, even when hosted in different nodes. Este ejemplo muestra cómo usar EventProcessorHost para un solo destinatario.This example shows how to use EventProcessorHost for a single receiver.

Crear una cuenta de almacenamientoCreate a storage account

Para usar EventProcessorHost, debe tener una [cuenta de Azure Storage][cuenta de Azure Storage]:To use EventProcessorHost, you must have an [Azure Storage account][Azure Storage account]:

  1. Inicie sesión en Azure Portal y haga clic en + Crear un recurso en la parte izquierda de la pantalla.Sign in the Azure portal, and click + Create a resource on the left-hand side of the screen.

  2. Haga clic en Storage y luego en Cuenta de Storage.Click Storage, then click Storage account. En la ventana Crear cuenta de almacenamiento, escriba un nombre para la cuenta de almacenamiento.In the Create storage account window, type a name for the storage account. Complete el resto de los campos, seleccione la región que desee y, finalmente, haga clic en Crear.Complete the rest of the fields, select your desired region, and then click Create.

    Crear cuenta de almacenamiento

  3. Haga clic en la cuenta de almacenamiento recién creada y, a continuación, en Claves de acceso:Click the newly created storage account, and then click Access Keys:

    Obtención de las claves de acceso

    Copie el valor key1 en una ubicación temporal.Copy the key1 value to a temporary location. Lo usará más adelante en este tutorial.You use it later in this tutorial.

Creación de un proyecto de Java mediante EventProcessorHostCreate a Java project using the EventProcessor Host

La biblioteca de cliente de Java para Event Hubs está disponible para su uso en proyectos de Maven en el repositorio central de Maven, y se puede hacer referencia a ella mediante la siguiente declaración de dependencia en el archivo de proyecto de 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>

Para distintos tipos de entornos de compilación, puede obtener explícitamente los últimos archivos JAR publicados del [repositorio central de Maven][https://search.maven.org/#search%7Cga%7C1%7Ca%3A%22azure-eventhubs-eph%22 ].For different types of build environments, you can explicitly obtain the latest released JAR files from the [Maven Central Repository][https://search.maven.org/#search%7Cga%7C1%7Ca%3A%22azure-eventhubs-eph%22].

  1. Para el ejemplo siguiente, primero cree un nuevo proyecto de Maven para una aplicación de consola o shell en su entorno de desarrollo de Java favorito.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. La clase se denomina 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. Cree una clase nueva denominada EventProcessorSamplecon el código siguiente.Use the following code to create a new class called EventProcessorSample. Reemplace los siguientes marcadores de posición por los valores que usó al crear el centro de eventos y la cuenta de almacenamiento: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. Cree una clase final más llamada EventProcessor, con el código siguiente: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());
        }
    }
    

Este tutorial usa una sola instancia de EventProcessorHost.This tutorial uses a single instance of EventProcessorHost. Para aumentar la capacidad de procesamiento, se recomienda ejecutar varias instancias de EventProcessorHost, preferiblemente en máquinas independientes.To increase throughput, we recommend that you run multiple instances of EventProcessorHost, preferably on separate machines. Esto proporciona redundancia también.It provides redundancy as well. En esos casos, las diferentes instancias se coordinan automáticamente entre sí con el fin de equilibrar la carga de los eventos recibidos.In those cases, the various instances automatically coordinate with each other in order to load balance the received events. Si desea que varios destinatarios procesen todos los eventos, debe usar el concepto ConsumerGroup .If you want multiple receivers to each process all the events, you must use the ConsumerGroup concept. Cuando se reciben eventos de distintos equipos, puede ser útil especificar nombres para las instancias de EventProcessorHost según los equipos (o roles) en que se implementan.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.

Publicación de mensajes en EventHubPublishing Messages to EventHub

Antes de que los consumidores puedan recuperar los mensajes, los editores tienen que publicarlos primero en las particiones.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. Merece la pena destacar que cuando los mensajes se publican en el centro de eventos de manera sincrónica con el método sendSync() en el objeto com.microsoft.azure.eventhubs.EventHubClient, se podrían enviar a una partición específica o distribuirse a todas las particiones disponibles en modo round-robin, según si se especifica o no la clave de partición.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.

Cuando se especifica una cadena que representa la clave de partición, se aplicará un algoritmo hash a la clave para determinar la partición a la que desea enviar el evento.When a string representing the partition key is specified, the key is hashed to determine which partition to send the event to.

Cuando no se establece la clave de partición, los mensajes se envían en modo round-robin a todas las particiones disponiblesWhen 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);

Implementación del administrador de puntos de control personalizado para EventProcessorHost (EPH)Implementing a Custom CheckpointManager for EventProcessorHost (EPH)

La API proporciona un mecanismo para implementar el administrador de puntos de control personalizado en escenarios donde la implementación predeterminada no es compatible con su caso de uso.The API provides a mechanism to implement your custom checkpoint manager for scenarios where the default implementation is not compatible with your use case.

El administrador de puntos de control predeterminado usa el almacenamiento de blobs, pero si reemplaza el administrador de puntos de control que usa EPH por su propia implementación, puede usar cualquier almacén que quiera para respaldar la implementación del administrador de puntos de control.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.

Cree una clase que implemente la interfaz com.microsoft.azure.eventprocessorhost.ICheckpointManager.Create a class that implements the interface com.microsoft.azure.eventprocessorhost.ICheckpointManager

Use la implementación personalizada del administrador de puntos de control (com.microsoft.azure.eventprocessorhost.ICheckpointManager).Use your custom implementation of the checkpoint manager (com.microsoft.azure.eventprocessorhost.ICheckpointManager)

Dentro de su implementación, puede reemplazar el mecanismo de puntos de control predeterminado e implementar nuestros propios puntos de control en función de su propio almacén de datos (SQL Server, CosmosDB y Azure Cache for Redis).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). Se recomienda que el almacén usado para respaldar la implementación del administrador de puntos de control sea accesible para todas las instancias de EPH que van a procesar eventos para el grupo de consumidores.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.

Puede usar cualquier almacén de datos que esté disponible en su entorno.You can use any datastore that is available in your environment.

La clase com.microsoft.azure.eventprocessorhost.EventProcessorHost proporciona dos constructores que le permiten reemplazar el administrador de puntos de control por EventProcessorHost.The com.microsoft.azure.eventprocessorhost.EventProcessorHost class provides you with two constructors that allow you to override the checkpoint manager for your EventProcessorHost.

Pasos siguientesNext steps

Lea los siguientes artículos:Read the following articles: