Share via

Azure Event Grid Clientbibliothek für Java– Version 4.19.0

  • Artikel

Mit Azure Event Grid können Sie mühelos Anwendungen mit ereignisbasierten Architekturen erstellen. Der Event Grid-Dienst verwaltet das gesamte Routing von Ereignissen von jeder Quelle an jedes Ziel für jede Anwendung vollständig. Azure-Dienstereignisse und benutzerdefinierte Ereignisse können direkt im Dienst veröffentlicht werden, wo die Ereignisse dann gefiltert und an verschiedene Empfänger gesendet werden können, z. B. integrierte Handler oder benutzerdefinierte Webhooks. Weitere Informationen zu Azure Event Grid: Was ist Event Grid?

Verwenden Sie die Clientbibliothek für Azure Event Grid für Folgendes:

  • Veröffentlichen von Ereignissen im Event Grid-Dienst mithilfe von Event Grid-, Cloudereignis 1.0- oder benutzerdefinierten Schemas
  • Nutzen von Ereignissen, die an Ereignishandler übermittelt wurden
  • Generieren von SAS-Token zum Authentifizieren der Clientveröffentlichungsereignisse in Azure Event Grid Themen

Quellen | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Voraussetzungen

Wenn Sie die Azure CLI verwenden, ersetzen <your-resource-group-name> Sie und <your-resource-name> durch Ihre eigenen eindeutigen Namen und <location> durch einen gültigen Azure-Dienststandort.

Erstellen eines Themas (Azure CLI)

az eventgrid topic create --location <location> --resource-group <your-resource-group-name> --name <your-resource-name>

Erstellen einer Domäne (Azure CLI)

az eventgrid domain create --location <location> --resource-group <your-resource-group-name> --name <your-resource-name>

Einschließen des Pakets

BOM-Datei einfügen

Fügen Sie azure-sdk-bom in Ihr Projekt ein, um von der GA-Version der Bibliothek abhängig zu sein. Ersetzen Sie im folgenden Codeausschnitt den Platzhalter {bom_version_to_target} durch die Versionsnummer. Weitere Informationen zur BOM finden Sie in der INFODATEI FÜR AZURE SDK-STÜCKLISTEN.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

und fügen Sie dann die direkte Abhängigkeit ohne Versions-Tag in den Abschnitt „Abhängigkeit“ ein.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-messaging-eventgrid</artifactId>
  </dependency>
</dependencies>

Direkte Abhängigkeiten einfügen

Wenn Sie eine Abhängigkeit von einer bestimmten Version der Bibliothek annehmen möchten, die nicht in der BoM vorhanden ist, fügen Sie die direkte Abhängigkeit wie folgt zu Ihrem Projekt hinzu.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-messaging-eventgrid</artifactId>
    <version>4.19.0</version>
</dependency>

Authentifizieren des Clients

Um Ereignisse zu senden, benötigen wir einen Endpunkt, an den gesendet werden soll, und eine Authentifizierung für den Endpunkt. Bei der Authentifizierung kann es sich um Schlüsselanmeldeinformationen, eine Shared Access Signature oder eine Azure Active Directory-Tokenauthentifizierung handeln. Der Endpunkt und der Schlüssel können beide über das Azure-Portal oder die Azure CLI abgerufen werden.

Endpunkt

Der Endpunkt wird auf der Dashboard des Themas oder der Domäne im Azure-Portal aufgeführt oder kann mithilfe des folgenden Befehls in der Azure CLI abgerufen werden.

az eventgrid topic show --name <your-resource-name> --resource-group <your-resource-group-name> --query "endpoint"

Zugriffsschlüssel

Die Schlüssel werden im Azure-Portal auf der Registerkarte "Zugriffsschlüssel" aufgeführt oder können mithilfe des folgenden Befehls in der Azure CLI abgerufen werden. Jeder der aufgeführten Schlüssel funktioniert.

az eventgrid topic key list --name <your-resource-name> --resource-group <your-resource-group-name>

AAD-Tokenauthentifizierung (Azure Active Directory)

Azure Event Grid ermöglicht die Integration in Azure Active Directory (Azure AD) für die identitätsbasierte Authentifizierung von Anforderungen. Mit Azure AD können Sie die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) verwenden, um Benutzern, Gruppen oder Anwendungen Zugriff auf Ihre Azure Event Grid-Ressourcen zu gewähren. Um Ereignisse mit einem an ein Thema oder eine TokenCredentialDomäne zu senden, muss der authentifizierten Identität die Rolle "EventGrid-Datensender" zugewiesen sein.

Erstellen des Clients

Verwenden von Endpunkt und Zugriffsschlüssel zum Erstellen des Clients

Sobald Sie über Ihren Zugriffsschlüssel und Themenendpunkt verfügen, können Sie den Herausgeberclient wie folgt erstellen:

Synchronisierungsclient, der für jeden Java-Entwickler funktioniert:

// For CloudEvent
EventGridPublisherClient<CloudEvent> cloudEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildCloudEventPublisherClient();

// For EventGridEvent
EventGridPublisherClient<EventGridEvent> eventGridEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts EventGridEvent schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildEventGridEventPublisherClient();

// For custom event
EventGridPublisherClient<BinaryData> customEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts custom event schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildCustomEventPublisherClient();

oder asynchroner Client, wenn Ihr Technologiestapel über reaktive Programmierung verfügt, z. B. Projektreaktor:

// For CloudEvent
EventGridPublisherAsyncClient<CloudEvent> cloudEventAsyncClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildCloudEventPublisherAsyncClient();

// For EventGridEvent
EventGridPublisherAsyncClient<EventGridEvent> eventGridEventAsyncClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts EventGridEvent schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildEventGridEventPublisherAsyncClient();

// For custom event
EventGridPublisherAsyncClient<BinaryData> customEventAsyncClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts custom event schema>")
    .credential(new AzureKeyCredential("<key for the endpoint>"))
    .buildCustomEventPublisherAsyncClient();
Verwenden von Endpunkt und SAS-Token zum Erstellen des Clients

Wenn Sie über eine SAS (Shared Access Signature) verfügen, die zum Senden von Ereignissen an ein Event Grid-Thema oder eine Domäne für einen begrenzten Zeitraum verwendet werden kann, können Sie damit den Herausgeberclient erstellen:

Synchronisierungsclient:

EventGridPublisherClient<CloudEvent> cloudEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new AzureSasCredential("<sas token that can access the endpoint>"))
    .buildCloudEventPublisherClient();

Asynchroner Client:

EventGridPublisherAsyncClient<CloudEvent> cloudEventAsyncClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new AzureSasCredential("<sas token that can access the endpoint>"))
    .buildCloudEventPublisherAsyncClient();
Verwenden von Endpunkt- und Azure Active Directory-Tokenanmeldeinformationen (AAD) zum Erstellen des Clients

Um die Anmeldeinformationen des AAD-Tokens zu verwenden, schließen Sie azure-identity das Artefakt als Abhängigkeit ein. Ausführliche Informationen finden Sie unter azure-identity README .

Synchronisierungsclient:

EventGridPublisherClient<CloudEvent> cloudEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildCloudEventPublisherClient();

Asynchroner Client:

EventGridPublisherAsyncClient<CloudEvent> cloudEventClient = new EventGridPublisherClientBuilder()
    .endpoint("<endpoint of your event grid topic/domain that accepts CloudEvent schema>")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildCloudEventPublisherAsyncClient();

Erstellen eines SAS-Tokens für andere Personen zum Senden von Ereignissen für einen begrenzten Zeitraum

Wenn Sie anderen Personen die Berechtigung erteilen möchten, Ereignisse für einige Zeit in Ihrem Event Grid-Thema oder Ihrer Event Grid-Domäne zu veröffentlichen, können Sie eine SAS (Shared Access Signature) für sie erstellen, damit sie eine EventGridPublisherClient wie oben beschrieben erstellen können, um AzureSasCredential den Herausgeberclient zu erstellen.

Im Folgenden finden Sie Beispielcode zum Erstellen einer Shared Access Signature, die nach 20 Minuten abläuft:

OffsetDateTime expiration = OffsetDateTime.now().plusMinutes(20);
String sasToken = EventGridPublisherClient
    .generateSas("<your event grid endpoint>", new AzureKeyCredential("<key for the endpoint>"), expiration);

Verwenden Sie BinaryData

Dieses SDK verwendet com.azure.util.BinaryData , um die Datennutzlast von Ereignissen darzustellen. BinaryData unterstützt das Serialisieren und Deserialisieren von Objekten über com.azure.core.util.BinaryData.fromObject(Object object) methoden und toObject() , die ein Standardmäßiges Jackson Json-Serialisierungsprogramm verwenden, oder fromObject(Object object, ObjectSerializer customSerializer) und Methoden toObject(Class<T> clazz, ObjectSerializer serializer) , die Ihr angepasstes Json-Serialisierungsprogramm akzeptieren. Weitere Informationen finden Sie in der BinaryData-Dokumentation .

Wichtige Begriffe

Informationen zu allgemeinen Event Grid-Konzepten: Konzepte in Azure Event Grid.

EventGridPublisherClient

EventGridPublisherClient wird verwendet, um Ereignisse an ein Event Grid-Thema oder eine Event Grid-Domäne zu senden. EventGridPublisherAsyncClient ist die asynchrone Version von EventGridPublisherClient.

Ereignisschemas

Event Grid unterstützt mehrere Schemas für die Codierung von Ereignissen. Wenn ein Event Grid-Thema oder eine Domäne erstellt wird, geben Sie das Schema an, das beim Veröffentlichen von Ereignissen verwendet wird. Sie können Ihr Thema zwar für die Verwendung eines benutzerdefinierten Schemas konfigurieren, es ist jedoch üblicher, das bereits definierte EventGridEvent- oder CloudEvent-Schema zu verwenden. CloudEvent ist ein Cloud Native Computing Foundation-Projekt, das eine Spezifikation für die allgemeine Beschreibung von Ereignisdaten erstellt. Der Event Grid-Dienst ist mit der CloudEvent-Spezifikation kompatibel Unabhängig davon, für welches Schema Ihr Thema oder Ihre Domäne konfiguriert ist, EventGridPublisherClient wird zum Veröffentlichen von Ereignissen verwendet. Sie müssen jedoch den richtigen Typ verwenden, um ihn zu instanziieren:

Ereignisschema Generische Instanziierung des Verlegerclients
Event Grid-Ereignisse EventGridPublisherClient<EventGridEvent>
Cloudereignisse EventGridPublisherClient<CloudEvent>
Benutzerdefinierte Ereignisse EventGridPublisherClient<BinaryData>

Die Verwendung des falschen Typs führt zu einem BadRequest-Fehler des Diensts, und Ihre Ereignisse werden nicht veröffentlicht. Verwenden Sie diesen Azure CLI-Befehl, um abzufragen, welches Schema ein Event Grid-Thema oder eine Domäne akzeptiert:

az eventgrid topic show --name <your-resource-name> --resource-group <your-resource-group-name> --query inputSchema

Ereignishandler und Ereignisdeserialisierung.

EventGrid speichert keine Ereignisse im Event Grid-Thema oder der Domäne selbst. Sie müssen Abonnements für das EventGrid-Thema oder die Domäne erstellen. Die an das Thema oder die Domäne gesendeten Ereignisse werden im Endpunkt des Abonnements gespeichert, der auch als "Ereignishandler" bezeichnet wird.

Sie können das SDK des Ereignishandlers verwenden, um die Ereignisse in Json String zu empfangen und dann die EventGridEvent.fromString() Ereignisse zu deserialisieren oder CloudEvent.fromString() zu deserialisieren. Der Datenteil der Ereignisse kann binär, Zeichenfolgen- oder JSON-Daten sein.

Beispiele

Senden von Ereignissen an Event Grid-Themen

Ereignisse können in , EventGridEventCloudEventoder einem benutzerdefinierten Schema gesendet werden, wie unter Ereignisschemas beschrieben. Das Thema oder die Domäne muss so konfiguriert werden, dass das gesendete Schema akzeptiert wird. Der Einfachheit halber wird der synchrone Client für Beispiele verwendet, der asynchrone Client weist jedoch die gleichen Methodennamen auf.

Hinweis: Ermitteln Sie, welches Schema (Cloudereignis, Event Grid-Ereignis oder benutzerdefiniertes Ereignis) das Event Grid-Thema akzeptiert, bevor Sie mit dem Senden beginnen.

Senden EventGridEvent an ein Thema, das das EventGridEvent-Schema akzeptiert

// Make sure that the event grid topic or domain you're sending to is able to accept the EventGridEvent schema.
List<EventGridEvent> events = new ArrayList<>();
User user = new User("John", "James");
events.add(new EventGridEvent("exampleSubject", "Com.Example.ExampleEventType", BinaryData.fromObject(user), "0.1"));
eventGridEventClient.sendEvents(events);

Senden CloudEvent an ein Thema, das das CloudEvent-Schema akzeptiert

// Make sure that the event grid topic or domain you're sending to is able to accept the CloudEvent schema.
List<CloudEvent> events = new ArrayList<>();
User user = new User("John", "James");
events.add(new CloudEvent("https://source.example.com", "Com.Example.ExampleEventType",
    BinaryData.fromObject(user), CloudEventDataFormat.JSON, "application/json"));
cloudEventClient.sendEvents(events);

Senden von benutzerdefinierten Ereignissen an ein Thema, das ein benutzerdefiniertes Ereignisschema akzeptiert

// Make sure that the event grid topic or domain you're sending to is able to accept the custom event schema.
List<BinaryData> events = new ArrayList<>();
events.add(BinaryData.fromObject(new HashMap<String, String>() {
    {
        put("id", UUID.randomUUID().toString());
        put("time", OffsetDateTime.now().toString());
        put("subject", "Test");
        put("foo", "bar");
        put("type", "Microsoft.MockPublisher.TestEvent");
        put("data", "example data");
        put("dataVersion", "0.1");
    }
}));
customEventClient.sendEvents(events);

Senden von Ereignissen an die Event Grid-Domäne

Eine Event Grid-Domäne kann Tausende von Themen enthalten, verfügt aber über einen einzelnen Endpunkt. Sie können eine Domäne verwenden, um eine Reihe verwandter Themen zu verwalten. Das Senden von Ereignissen an die Themen einer Event Grid-Domäne entspricht dem Senden von Ereignissen an ein reguläres Event Grid-Thema, mit der Ausnahme, dass Sie die topic eines EventGridEvent angeben müssen, wenn die Domäne das Schema akzeptiert EventGridEvent .

List<EventGridEvent> events = new ArrayList<>();
User user = new User("John", "James");
events.add(new EventGridEvent("com/example", "Com.Example.ExampleEventType", BinaryData.fromObject(user), "1")
    .setTopic("yourtopic"));
eventGridEventClient.sendEvents(events);

Wenn die Domäne das Schema akzeptiert CloudEvent , muss das CloudEvent-Attribut festgelegt werden, das für die Zuordnung des topic beim Erstellen der Domäne konfiguriert ist. Das Standardzuordnungsattribut ist source.

Empfangen und Nutzen von Ereignissen

Der Event Grid-Dienst speichert keine Ereignisse. Daher verfügt dieses Event Grid SDK nicht über einen Ereignisempfänger. Stattdessen werden Ereignisse in den Ereignishandlern gespeichert, einschließlich ServiceBus, EventHubs, Speicherwarteschlange, WebHook-Endpunkt oder vielen anderen unterstützten Azure-Diensten. Derzeit werden jedoch alle Ereignisse als codierte JSON-Daten gesendet und gespeichert. Im Folgenden finden Sie einige grundlegende Codeinformationen zur Deserialisierung von Ereignissen, nachdem sie von den Ereignishandlern empfangen wurden. Auch hier unterscheidet sich die Behandlung basierend auf dem Ereignisschema, das vom Thema/Abonnement empfangen wird.

Deserialisieren EventGridEvent oder CloudEvent aus einer JSON-Zeichenfolge

Die JSON-Zeichenfolge kann ein einzelnes Ereignis oder ein Array von Ereignissen aufweisen. Das zurückgegebene Ergebnis ist eine Liste von Ereignissen.

// Deserialize an EventGridEvent
String eventGridEventJsonData = "<your EventGridEvent json String>";
List<EventGridEvent> eventGridEvents = EventGridEvent.fromString(eventGridEventJsonData);

// Deserialize a CloudEvent
String cloudEventJsonData = "<your CloudEvent json String>";
List<CloudEvent> cloudEvents = CloudEvent.fromString(cloudEventJsonData);

Deserialisieren von Daten aus einem CloudEvent oder EventGridEvent

Nachdem Sie oder EventGridEventCloudEvent aus einer JSON-Zeichenfolge deserialisiert haben, können Sie oder EventGridEvent verwenden getData()CloudEvent, um die Nutzlast des Ereignisses abzurufen. Es gibt ein BinaryData -Objekt zurück, das Über Methoden zum weiteren Deserialisieren der Daten in verwendbare Typen verfügt:

  • BinaryData.toBytes() ruft die Daten als Byte[] ab.
  • BinaryData.toString() ruft die Daten als Zeichenfolge ab.
  • BinaryData.toObject() ruft die Daten als Objekt eines bestimmten Typs ab. Standardmäßig wird Json-Deserialisierer verwendet. Es verfügt über eine Überladung, um Ihren Deserialisierer zu akzeptieren, wenn Sie Ihren eigenen verwenden möchten.
BinaryData eventData = eventGridEvent.getData();

//Deserialize data to a model class
User dataInModelClass = eventData.toObject(User.class);

//Deserialize data to a Map
Map<String, Object> dataMap = eventData.toObject(new TypeReference<Map<String, Object>>() {
});

//Deserialize Json String to a String
String dataString = eventData.toObject(String.class);

//Deserialize String data to a String
String dataInJsonString = eventData.toString();

//Deserialize data to byte array (byte[])
byte[] dataInBytes = eventData.toBytes();

Deserialisieren von Systemereignisdaten aus CloudEvent oder EventGridEvent

Ein Ereignis, das an ein Systemthema gesendet wird, wird als Systemthemaereignis oder Systemereignis bezeichnet. Ein Systemthema in Event Grid stellt Ereignisse dar, die von einer Ereignisquelle wie Azure Storage, Azure Event Hubs, App Configuration usw. veröffentlicht werden. Ein Beispiel ist, wenn ein Blob erstellt wird, wird ein Systemereignis mit dem Ereignistyp "Microsoft.Storage.BlobCreated" an das konfigurierte Systemthema gesendet. Die Systemereignisklasse für diesen Ereignistyp ist StorageBlobCreatedEventData im Paket com.azure.messaging.eventgrid.systemeventsdefiniert. EventGrid verfügt über Systemereignisse für:

Sie können mit diesem SDK kein Systemereignis an ein Systemthema senden.

Das Empfangen und Nutzen von Systemereignissen ist identisch mit anderen Ereignissen. Darüber hinaus werden im Paket com.azure.messaging.eventgrid.systemeventseine Reihe von Modellklassen für die verschiedenen Systemereignisdaten definiert. Sie können die folgenden Schritte ausführen, nachdem Sie ein Ereignis mit EventGridEvent.fromString() oder CloudEvent.fromString()deserialisiert haben:

  • Suchen Sie die Systemereignisdatenmodellklasse, in die die Systemereignisdaten deserialisiert werden können.
// Look up the System Event data class
Class<?> eventDataClazz = SystemEventNames.getSystemEventMappings().get(event.getEventType());
  • Deserialisieren der Daten eines Systemereignisses in eine Modellklasse instance wie das Deserialisieren anderer Ereignisdaten;
// Deserialize the event data to an instance of a specific System Event data class type
BinaryData data = event.getData();
if (data != null) {
    StorageBlobCreatedEventData blobCreatedData = data.toObject(StorageBlobCreatedEventData.class);
    System.out.println(blobCreatedData.getUrl());
}
  • behandeln mehrere Ereignistypen.
List<EventGridEvent> eventGridEvents = EventGridEvent.fromString("<Your EventGridEvent Json String>");
for (EventGridEvent eventGridEvent : eventGridEvents) {
    BinaryData binaryData = eventGridEvent.getData();
    switch (eventGridEvent.getEventType()) {
        case SystemEventNames.APP_CONFIGURATION_KEY_VALUE_DELETED:
            AppConfigurationKeyValueDeletedEventData keyValueDeletedEventData =
                binaryData.toObject(TypeReference.createInstance(AppConfigurationKeyValueDeletedEventData.class));
            System.out.println("Processing the AppConfigurationKeyValueDeletedEventData...");
            System.out.printf("The key is: %s%n", keyValueDeletedEventData.getKey());
            break;
        case SystemEventNames.APP_CONFIGURATION_KEY_VALUE_MODIFIED:
            AppConfigurationKeyValueModifiedEventData keyValueModifiedEventData =
                binaryData.toObject(TypeReference.createInstance(AppConfigurationKeyValueModifiedEventData.class));
            System.out.println("Processing the AppConfigurationKeyValueModifiedEventData...");
            System.out.printf("The key is: %s%n", keyValueModifiedEventData.getKey());
            break;
        default:
            System.out.printf("%s isn't an AppConfiguration event data%n", eventGridEvent.getEventType());
            break;
    }
}

Weitere Beispiele

Einige zusätzliche Beispielcode finden Sie hier.

Problembehandlung

Antworten und Fehlercodes

Dienstantworten werden in Form von Http-status-Codes zurückgegeben, einschließlich einer Reihe von Fehlercodes. Diese Codes können optional vom PublisherClientzurückgegeben werden. Unerwartete status Codes ausgelöst werden, die HttpResponseException den Fehlercode umschließen.

Die Referenzdokumentation für den Event Grid-Dienst finden Sie hier. Dies ist ein guter Ausgangspunkt für Probleme mit der Konfiguration von Themen/Endpunkten sowie für Probleme mit Fehlercodes des Diensts.

Verteilte Ablaufverfolgung

Die Event Grid-Bibliothek unterstützt die sofort einsatzbereite Verteilung der Ablaufverfolgung. Um dem Leitfaden der CloudEvents-Spezifikation für verteilte Ablaufverfolgung zu genügen, legt die Bibliothek traceparent und tracestate für die extensionAttributes eines CloudEvent fest, wenn verteilte Ablaufverfolgung aktiviert ist. Weitere Informationen zum Aktivieren von verteilter Ablaufverfolgung in Ihrer Anwendung finden Sie im Azure SDK in der Dokumentation zur verteilten Ablaufverfolgung für Java.

Hilfe und Probleme

Die Referenzdokumentation für das SDK finden Sie hier. Dies ist ein guter erster Schritt, um den Zweck jeder aufgerufenen Methode sowie mögliche Gründe für Fehler oder unerwartetes Verhalten zu verstehen.

Wenn Bei diesen SDKs Fehler auftreten, melden Sie Probleme über Probleme , oder checken Sie StackOverflow für das Azure Java SDK aus.

Nächste Schritte

  • Azure Java SDKs
  • Wenn Sie kein Microsoft Azure-Abonnement besitzen, können Sie hier ein KOSTENLOSES Testkonto erhalten.
  • Einige zusätzliche Beispielcode finden Sie hier.
  • Weitere Event Grid-Tutorials finden Sie hier.

Mitwirken

Ausführliche Informationen zum Mitwirken an diesem Repository finden Sie im Leitfaden zum Mitwirken.

  1. Verzweigen sie
  2. Erstellen Ihrer Featurebranch (git checkout -b my-new-feature)
  3. Committen Ihrer Änderungen (git commit -am 'Add some feature')
  4. Pushen in den Branch (git push origin my-new-feature)
  5. Erstellen eines neuen Pull Requests

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.

Aufrufe