Senden von Protokolldaten an Azure Monitor mithilfe der HTTP-Datensammler-API (veraltet)

In diesem Artikel wird gezeigt, wie Sie die HTTP-Datensammler-API verwenden, um Protokolldaten von einem REST-API-Client an Azure Monitor zu senden. In dem Dokument wird beschrieben, wie Daten formatiert werden, die von Ihrem Skript oder Ihrer Anwendung gesammelt werden, wie sie in eine Anforderung eingeschlossen werden und wie diese Anforderung von Azure Monitor autorisiert wird. Wir stellen Beispiele für Azure PowerShell, C# und Python bereit.

Anmerkung

Die HTTP-Datensammler-API von Azure Monitor ist veraltet und ist ab dem 14.09.2026 nicht mehr funktionsfähig. Die Protokollaufnahme-API hat die alte Lösungersetzt.

Konzepte

Sie können die HTTP-Datensammler-API verwenden, um Protokolldaten von jedem Client aus, der eine REST-API aufrufen kann, an einen Log Analytics-Arbeitsbereich in Azure Monitor zu senden. Der Client kann ein Runbook in Azure Automation sein, das Verwaltungsdaten aus Azure oder einer anderen Cloud sammelt, oder es kann ein alternatives Verwaltungssystem sein, das Azure Monitor zum Konsolidieren und Analysieren von Protokolldaten verwendet.

Alle Daten im Log Analytics-Arbeitsbereich werden als Datensatz mit einem bestimmten Datensatztyp gespeichert. Sie formatieren Ihre Daten, die an die HTTP-Datensammler-API gesendet werden sollen, als mehrere Datensätze in JavaScript Object Notation (JSON). Wenn Sie die Daten übermitteln, wird für jeden Datensatz in der Anforderungsnutzlast ein eigener Datensatz im Repository erstellt.

Anforderung erstellen

Um die HTTP-Datensammler-API zu verwenden, erstellen Sie eine POST-Anforderung, die die zu sendenden Daten in JSON enthält. In den nächsten drei Tabellen sind die Attribute aufgeführt, die für jede Anforderung erforderlich sind. Die einzelnen Attribute werden weiter unten im Artikel ausführlicher beschrieben.

Anforderungs-URI

Attribut	Eigentum
Methode	BEREITSTELLEN
URI	https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01
Inhaltstyp	application/json

Anforderungs-URI-Parameter

Parameter	Beschreibung
Kundennummer	Der eindeutige Bezeichner für den Log Analytics-Arbeitsbereich.
Ressource	Der API-Ressourcenname: /api/logs.
API-Version	Die Version der API, die mit dieser Anforderung verwendet werden soll. Derzeit ist die Version 2016-04-01.

Anforderungsheader

Überschrift	Beschreibung
Ermächtigung	Die Autorisierungssignatur. Weiter unten im Artikel erfahren Sie, wie Sie eine HMAC-SHA256 Kopfzeile erstellen.
Log-Type	Geben Sie den Datensatztyp der übermittelten Daten an. Er darf nur Buchstaben, Zahlen und das Unterstrichzeichen (_) enthalten, und er darf 100 Zeichen nicht überschreiten.
x-ms-date	Das Datum, an dem die Anforderung verarbeitet wurde, im Format RFC 1123.
x-ms-AzureResourceId	Die Ressourcen-ID der Azure-Ressource, der die Daten zugeordnet werden sollen. Sie füllt die _ResourceId-Eigenschaft aus und ermöglicht die Aufnahme der Daten in Ressourcenkontext--Abfragen. Wenn dieses Feld nicht angegeben ist, werden die Daten nicht in Ressourcenkontextabfragen einbezogen.
zeitgeneriertes Feld	Der Name eines Felds in den Daten, die den Zeitstempel des Datenelements enthalten. Wenn Sie ein Feld angeben, werden dessen Inhalte für TimeGeneratedverwendet. Wenn Sie dieses Feld nicht angeben, ist die Standardeinstellung für TimeGenerated der Zeitpunkt, zu dem die Nachricht empfangen wird. Der Inhalt des Nachrichtenfelds sollte dem ISO 8601-Format JJJJ-MM-DDThh:mm:ssZ entsprechen. Der Wert der Zeitgenerierung darf nicht älter als zwei Tage vor der Empfangszeit oder mehr als einen Tag in der Zukunft sein. In diesem Fall wird die Uhrzeit, zu der die Nachricht erfasst wird, verwendet.

Ermächtigung

Jede Anforderung an die Azure Monitor HTTP Data Collector-API muss einen Autorisierungsheader enthalten. Um eine Anforderung zu authentifizieren, signieren Sie die Anforderung entweder mit dem primären oder dem sekundären Schlüssel für den Arbeitsbereich, der die Anforderung vornimmt. Dann übergeben Sie diese Signatur als Teil der Anforderung.

Hier ist das Format für den Autorisierungsheader:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID- ist die eindeutige Kennung für den Arbeitsbereich von Log Analytics. Die Signatur ist einen hashbasierten Nachrichtenauthentifizierungscode (HMAC), der aus der Anforderung erstellt und dann mithilfe des SHA256-Algorithmusberechnet wird. Anschließend codieren Sie sie mithilfe der Base64-Codierung.

Verwenden Sie dieses Format, um die SharedKey Signaturzeichenfolge zu codieren:

StringToSign = VERB + "\n" +
                  Content-Length + "\n" +
                  Content-Type + "\n" +
                  "x-ms-date:" + x-ms-date + "\n" +
                  "/api/logs";

Hier ist ein Beispiel für einen Signaturstring.

POST\n1024\napplication/json\nx-ms-date:Mon, 04 Apr 2016 08:00:00 GMT\n/api/logs

Wenn Sie über die Signaturzeichenfolge verfügen, verschlüsseln Sie sie mithilfe des HMAC-SHA256-Algorithmus auf der UTF-8-codierten Zeichenfolge, und kodieren Sie das Ergebnis anschließend in Base64. Verwenden Sie dieses Format:

Signature=Base64(HMAC-SHA256(UTF8(StringToSign)))

Die Beispiele in den nächsten Abschnitten enthalten Beispielcode, mit dem Sie einen Autorisierungsheader erstellen können.

Anfragekörper

Der Textkörper der Nachricht muss in JSON enthalten sein. Sie muss einen oder mehrere Datensätze mit dem Eigenschaftennamen und den Wertpaaren im folgenden Format enthalten. Der Eigenschaftsname darf nur Buchstaben, Zahlen und das Unterstrichzeichen (_) enthalten.

[
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    }
]

Sie können mehrere Datensätze in einer einzigen Anforderung mithilfe des folgenden Formats zusammen stapeln. Alle Datensätze müssen denselben Datensatztyp aufweisen.

[
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    },
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    }
]

Datensatztyp und -eigenschaften

Sie definieren einen benutzerdefinierten Datensatztyp, wenn Sie Daten über die Azure Monitor-HTTP-Datensammler-API übermitteln. Derzeit können Sie keine Daten in bestehende Datensatztypen schreiben, die von anderen Datentypen und Lösungen erstellt wurden. Azure Monitor liest die eingehenden Daten und erstellt dann Eigenschaften, die den Datentypen der eingegebenen Werte entsprechen.

Jede Anforderung an die Datensammler-API muss einen Log-Type- Header mit dem Namen für den Datensatztyp enthalten. Das Suffix _CL wird automatisch an den Namen angefügt, den Sie eingeben, um ihn von anderen Protokolltypen als benutzerdefiniertes Protokoll zu unterscheiden. Wenn Sie beispielsweise den Namen MyNewRecordTypeeingeben, erstellt Azure Monitor einen Datensatz mit dem Typ MyNewRecordType_CL. Dadurch wird sichergestellt, dass es keine Konflikte zwischen vom Benutzer erstellten Typnamen und den in aktuellen oder zukünftigen Microsoft-Lösungen enthaltenen gibt.

Um den Datentyp einer Eigenschaft zu identifizieren, fügt Azure Monitor dem Eigenschaftennamen ein Suffix hinzu. Wenn eine Eigenschaft einen NULL-Wert enthält, ist die Eigenschaft nicht in diesem Datensatz enthalten. Diese Tabelle listet den Datentyp der Eigenschaft und das entsprechende Suffix auf:

Eigenschafts-Datentyp	Nachsilbe
Schnur	_s
Boolesch	_b
Doppelt	_d
Datum/Uhrzeit	_t
GUID (als Zeichenfolge gespeichert)	_g

Anmerkung

Zeichenfolgenwerte, die wie GUIDs erscheinen, erhalten das Suffix _g und werden als GUID formatiert, selbst wenn der eingehende Wert keine Bindestriche enthält. Beispiel: Sowohl "8145d822-13a7-44ad-859c-36f31a84f6dd" als auch "8145d82213a744ad859c36f31a84f6dd" werden als "8145d822-13a7-44ad-859c-36f31a84f6dd" gespeichert. Die einzigen Unterschiede zwischen dieser und einer anderen Zeichenfolge sind das _g im Namen und das Hinzufügen von Bindestrichen, wenn sie in der Eingabe nicht vorhanden sind.

Der Datentyp, den Azure Monitor für jede Eigenschaft verwendet, hängt davon ab, ob der Datensatztyp für den neuen Datensatz bereits vorhanden ist.

• Wenn der Datensatztyp nicht vorhanden ist, erstellt Azure Monitor mithilfe der JSON-Typzuleitung einen neuen Typ, um den Datentyp für jede Eigenschaft für den neuen Datensatz zu bestimmen.
• Wenn der Datensatztyp vorhanden ist, versucht Azure Monitor, einen neuen Datensatz basierend auf vorhandenen Eigenschaften zu erstellen. Wenn der Datentyp für eine Eigenschaft im neuen Datensatz nicht übereinstimmt und nicht in den vorhandenen Typ konvertiert werden kann oder wenn der Datensatz eine Eigenschaft enthält, die nicht vorhanden ist, erstellt Azure Monitor eine neue Eigenschaft mit dem relevanten Suffix.

Beispielsweise würde der folgende Übermittlungseintrag einen Datensatz mit drei Eigenschaften, number_d, boolean_bund string_serstellen:

Wenn Sie diesen nächsten Eintrag übermitteln würden, wobei alle Werte als Zeichenfolgen formatiert sind, würden sich die Eigenschaften nicht ändern. Sie können die Werte in vorhandene Datentypen konvertieren.

Wenn Sie diese nächste Übermittlung vornehmen, erstellt Azure Monitor jedoch die neuen Eigenschaften boolean_d und string_d. Sie können diese Werte nicht konvertieren.

Wenn Sie dann den folgenden Eintrag übermitteln, bevor der Datensatztyp erstellt wird, erstellt Azure Monitor einen Datensatz mit drei Eigenschaften, number_s, boolean_sund string_s. In diesem Eintrag wird jeder der anfangswerte als Zeichenfolge formatiert:

Reservierte Eigenschaften

Die folgenden Eigenschaften sind reserviert und sollten nicht in einem benutzerdefinierten Datensatztyp verwendet werden. Wenn Ihre Nutzlast einen der folgenden Eigenschaftennamen enthält, wird eine Fehlermeldung angezeigt:

• Mieter
• TimeGenerated
• Rohdaten

Datenlimits

Die in der Azure Monitor-Datensammlungs-API bereitgestellten Daten unterliegen bestimmten Einschränkungen:

• Maximal 30 MB pro Beitrag zur Azure Monitor Data Collector-API. Dies ist eine Größenbeschränkung für einen einzelnen Beitrag. Wenn die Daten aus einem einzelnen Beitrag 30 MB überschreiten, sollten Sie die Daten in kleinere Blöcke aufteilen und gleichzeitig senden.
• Maximal 32 KB für Feldwerte. Wenn der Feldwert größer als 32 KB ist, werden die Daten gekürzt.
• Empfohlener Maximalwert von 50 Feldern für einen bestimmten Typ. Dies ist ein praktischer Grenzwert aus Sicht der Benutzerfreundlichkeit und Sucherfahrung.
• Tabellen in Log Analytics-Arbeitsbereichen unterstützen nur bis zu 500 Spalten (in diesem Artikel als Felder bezeichnet).
• Maximal 45 Zeichen für Spaltennamen.

Rückgabecodes

Der HTTP-Statuscode 200 bedeutet, dass die Anforderung zur Verarbeitung empfangen wurde. Dies gibt an, dass der Vorgang erfolgreich abgeschlossen wurde.

Der vollständige Satz von Statuscodes, die der Dienst zurückgeben kann, ist in der folgenden Tabelle aufgeführt:

Code	Status	Fehlercode	Beschreibung
200	OKAY		Die Anforderung wurde erfolgreich akzeptiert.
400	Fehlerhafte Anfrage	InaktiverKunde	Der Arbeitsbereich wurde geschlossen.
400	Ungültige Anforderung	UngültigeApiVersion	Die angegebene API-Version wurde vom Dienst nicht erkannt.
400	Ungültige Anforderung	UngültigeKundenID	Die angegebene Arbeitsbereichs-ID ist ungültig.
400	Ungültige Anforderung	Ungültiges Datenformat	Ein ungültiger JSON-Code wurde übermittelt. Der Antworttext enthält möglicherweise weitere Informationen zum Beheben des Fehlers.
400	Fehlerhafte Anfrage	UngültigerProtokolltyp	Der angegebene Protokolltyp enthielt Sonderzeichen oder Zahlen.
400	Ungültige Anforderung	Fehlende API-Version	Die API-Version wurde nicht angegeben.
400	Ungültige Anforderung	FehlenderInhaltstyp	Der Inhaltstyp wurde nicht angegeben.
400	Ungültige Anforderung	MissingLogType	Der erforderliche Wertprotokolltyp wurde nicht angegeben.
400	Fehlerhafte Anfrage	Nicht unterstützter Inhaltstyp	Der Inhaltstyp wurde nicht auf application/jsonfestgelegt.
403	Verboten	Ungültige Autorisierung	Fehler beim Authentifizieren der Anforderung durch den Dienst. Überprüfen Sie, ob die Arbeitsbereichs-ID und der Verbindungsschlüssel gültig sind.
404	Nicht gefunden		Entweder ist die bereitgestellte URL falsch, oder die Anforderung ist zu groß.
429	Zu viele Anforderungen		Der Dienst erfährt ein hohes Datenvolumen von Ihrem Konto. Versuchen Sie die Anforderung später erneut.
500	Interner Serverfehler	UnbestimmterFehler	Der Dienst hat einen internen Fehler festgestellt. Versuchen Sie die Anforderung erneut.
503	Dienst nicht verfügbar	Dienst nicht verfügbar	Der Dienst ist zurzeit nicht verfügbar, um Anfragen zu empfangen. Versuchen Sie Ihre Anfrage erneut.

Abfragedaten

Um die von der Azure Monitor HTTP-Datensammler-API übermittelten Daten abzufragen, suchen Sie nach Datensätzen, deren Typ dem von Ihnen angegebenen und mit _CLangehängten LogType-Wert entspricht. Wenn Sie z. B. MyCustomLogverwendet haben, würden Sie alle Datensätze mit MyCustomLog_CLzurückgeben.

Beispielanforderungen

In diesem Abschnitt finden Sie Beispiele, die veranschaulichen, wie Daten mithilfe verschiedener Programmiersprachen an die AZURE Monitor-HTTP-Datensammler-API übermittelt werden.

Legen Sie für jedes Beispiel die Variablen für den Autorisierungsheader wie folgt fest:

1. Suchen Sie im Azure-Portal Ihren Log Analytics-Arbeitsbereich.
2. Wählen Sie Agentsaus.
3. Wählen Sie rechts neben Arbeitsbereichs-IDdas Symbol Kopieren aus, und fügen Sie dann die ID als Wert der Variablen Kunden-ID ein.
4. Wählen Sie rechts neben Primärschlüsseldas Symbol Kopieren aus, und fügen Sie dann die ID als Wert der Variablen GemeinsamerSchlüssel ein.

Alternativ können Sie die Variablen für den Protokolltyp und JSON-Daten ändern.

PowerShell

# Replace with your Workspace ID
$CustomerId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"  

# Replace with your Primary Key
$SharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Specify the name of the record type that you'll be creating
$LogType = "MyRecordType"

# Optional name of a field that includes the timestamp for the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
$TimeStampField = ""

# Create two records with the same set of properties to create
$json = @"
[{  "StringValue": "MyString1",
    "NumberValue": 42,
    "BooleanValue": true,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "9909ED01-A74C-4874-8ABF-D2678E3AE23D"
},
{   "StringValue": "MyString2",
    "NumberValue": 43,
    "BooleanValue": false,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "8809ED01-A74C-4874-8ABF-D2678E3AE23D"
}]
"@

# Create the function to create the authorization signature
Function Build-Signature ($customerId, $sharedKey, $date, $contentLength, $method, $contentType, $resource)
{
    $xHeaders = "x-ms-date:" + $date
    $stringToHash = $method + "`n" + $contentLength + "`n" + $contentType + "`n" + $xHeaders + "`n" + $resource

    $bytesToHash = [Text.Encoding]::UTF8.GetBytes($stringToHash)
    $keyBytes = [Convert]::FromBase64String($sharedKey)

    $sha256 = New-Object System.Security.Cryptography.HMACSHA256
    $sha256.Key = $keyBytes
    $calculatedHash = $sha256.ComputeHash($bytesToHash)
    $encodedHash = [Convert]::ToBase64String($calculatedHash)
    $authorization = 'SharedKey {0}:{1}' -f $customerId,$encodedHash
    return $authorization
}

# Create the function to create and post the request
Function Post-LogAnalyticsData($customerId, $sharedKey, $body, $logType)
{
    $method = "POST"
    $contentType = "application/json"
    $resource = "/api/logs"
    $rfc1123date = [DateTime]::UtcNow.ToString("r")
    $contentLength = $body.Length
    $signature = Build-Signature `
        -customerId $customerId `
        -sharedKey $sharedKey `
        -date $rfc1123date `
        -contentLength $contentLength `
        -method $method `
        -contentType $contentType `
        -resource $resource
    $uri = "https://" + $customerId + ".ods.opinsights.azure.com" + $resource + "?api-version=2016-04-01"

    $headers = @{
        "Authorization" = $signature;
        "Log-Type" = $logType;
        "x-ms-date" = $rfc1123date;
        "time-generated-field" = $TimeStampField;
    }

    $response = Invoke-WebRequest -Uri $uri -Method $method -ContentType $contentType -Headers $headers -Body $body -UseBasicParsing
    return $response.StatusCode

}

# Submit the data to the API endpoint
Post-LogAnalyticsData -customerId $customerId -sharedKey $sharedKey -body ([System.Text.Encoding]::UTF8.GetBytes($json)) -logType $logType  

C#

using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace OIAPIExample
{
    class ApiExample
    {
        // An example JSON object, with key/value pairs
        static string json = @"[{""DemoField1"":""DemoValue1"",""DemoField2"":""DemoValue2""},{""DemoField3"":""DemoValue3"",""DemoField4"":""DemoValue4""}]";

        // Update customerId to your Log Analytics workspace ID
        static string customerId = "xxxxxxxx-xxx-xxx-xxx-xxxxxxxxxxxx";

        // For sharedKey, use either the primary or the secondary Connected Sources client authentication key   
        static string sharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
        
        // LogName is name of the event type that is being submitted to Azure Monitor
        static string LogName = "DemoExample";
        
        // You can use an optional field to specify the timestamp from the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
        static string TimeStampField = "";
        
        static void Main()
        {
            // Create a hash for the API signature
            var datestring = DateTime.UtcNow.ToString("r");
            var jsonBytes = Encoding.UTF8.GetBytes(json);
            string stringToHash = "POST\n" + jsonBytes.Length + "\napplication/json\n" + "x-ms-date:" + datestring + "\n/api/logs";
            string hashedString = BuildSignature(stringToHash, sharedKey);
            string signature = "SharedKey " + customerId + ":" + hashedString;
        
            PostData(signature, datestring, json);
        }
        
        // Build the API signature
        public static string BuildSignature(string message, string secret)
        {
            var encoding = new System.Text.ASCIIEncoding();
            byte[] keyByte = Convert.FromBase64String(secret);
            byte[] messageBytes = encoding.GetBytes(message);
            using (var hmacsha256 = new HMACSHA256(keyByte))
            {
                byte[] hash = hmacsha256.ComputeHash(messageBytes);
                return Convert.ToBase64String(hash);
            }
        }
        
        // Send a request to the POST API endpoint
        public static void PostData(string signature, string date, string json)
        {
            try
            {
                string url = "https://" + customerId + ".ods.opinsights.azure.com/api/logs?api-version=2016-04-01";
        
                System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
                client.DefaultRequestHeaders.Add("Accept", "application/json");
                client.DefaultRequestHeaders.Add("Log-Type", LogName);
                client.DefaultRequestHeaders.Add("Authorization", signature);
                client.DefaultRequestHeaders.Add("x-ms-date", date);
                client.DefaultRequestHeaders.Add("time-generated-field", TimeStampField);
        
                // If charset=utf-8 is part of the content-type header, the API call may return forbidden.
                System.Net.Http.HttpContent httpContent = new StringContent(json, Encoding.UTF8);
                httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                Task<System.Net.Http.HttpResponseMessage> response = client.PostAsync(new Uri(url), httpContent);
        
                System.Net.Http.HttpContent responseContent = response.Result.Content;
                string result = responseContent.ReadAsStringAsync().Result;
                Console.WriteLine("Return Result: " + result);
            }
            catch (Exception excep)
            {
                Console.WriteLine("API Post Exception: " + excep.Message);
            }
        }
    }
}

Python

Anmerkung

Wenn Sie Python 2 verwenden, müssen Sie möglicherweise die Zeile ändern: bytes_to_hash = bytes(string_to_hash, encoding="utf-8") bis bytes_to_hash = bytes(string_to_hash).encode("utf-8")

import json
import requests
import datetime
import hashlib
import hmac
import base64

# Update the customer ID to your Log Analytics workspace ID
customer_id = 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'

# For the shared key, use either the primary or the secondary Connected Sources client authentication key   
shared_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# The log type is the name of the event that is being submitted
log_type = 'WebMonitorTest'

# An example JSON web monitor object
json_data = [{
   "slot_ID": 12345,
    "ID": "5cdad72f-c848-4df0-8aaa-ffe033e75d57",
    "availability_Value": 100,
    "performance_Value": 6.954,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "true"
},
{   
    "slot_ID": 67890,
    "ID": "b6bee458-fb65-492e-996d-61c4d7fbb942",
    "availability_Value": 100,
    "performance_Value": 3.379,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "false"
}]
body = json.dumps(json_data)

#####################
######Functions######  
#####################

# Build the API signature
def build_signature(customer_id, shared_key, date, content_length, method, content_type, resource):
    x_headers = 'x-ms-date:' + date
    string_to_hash = method + "\n" + str(content_length) + "\n" + content_type + "\n" + x_headers + "\n" + resource
    bytes_to_hash = bytes(string_to_hash, encoding="utf-8")  
    decoded_key = base64.b64decode(shared_key)
    encoded_hash = base64.b64encode(hmac.new(decoded_key, bytes_to_hash, digestmod=hashlib.sha256).digest()).decode()
    authorization = "SharedKey {}:{}".format(customer_id,encoded_hash)
    return authorization

# Build and send a request to the POST API
def post_data(customer_id, shared_key, body, log_type):
    method = 'POST'
    content_type = 'application/json'
    resource = '/api/logs'
    rfc1123date = datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
    content_length = len(body)
    signature = build_signature(customer_id, shared_key, rfc1123date, content_length, method, content_type, resource)
    uri = 'https://' + customer_id + '.ods.opinsights.azure.com' + resource + '?api-version=2016-04-01'

    headers = {
        'content-type': content_type,
        'Authorization': signature,
        'Log-Type': log_type,
        'x-ms-date': rfc1123date
    }

    response = requests.post(uri,data=body, headers=headers)
    if (response.status_code >= 200 and response.status_code <= 299):
        print('Accepted')
    else:
        print("Response code: {}".format(response.status_code))

post_data(customer_id, shared_key, body, log_type)

Java

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.MediaType;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Calendar;
import java.util.TimeZone;
import java.util.Locale;

import static org.springframework.http.HttpHeaders.CONTENT_TYPE;

public class ApiExample {

  private static final String workspaceId = "xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
  private static final String sharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
  private static final String logName = "DemoExample";
  /*
  You can use an optional field to specify the timestamp from the data. If the time field is not specified,
  Azure Monitor assumes the time is the message ingestion time
   */
  private static final String timestamp = "";
  private static final String json = "{\"name\": \"test\",\n" + "  \"id\": 1\n" + "}";
  private static final String RFC_1123_DATE = "EEE, dd MMM yyyy HH:mm:ss z";

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    String dateString = getServerTime();
    String httpMethod = "POST";
    String contentType = "application/json";
    String xmsDate = "x-ms-date:" + dateString;
    String resource = "/api/logs";
    String stringToHash = String
        .join("\n", httpMethod, String.valueOf(json.getBytes(StandardCharsets.UTF_8).length), contentType,
            xmsDate , resource);
    String hashedString = getHMAC256(stringToHash, sharedKey);
    String signature = "SharedKey " + workspaceId + ":" + hashedString;

    postData(signature, dateString, json);
  }

  private static String getServerTime() {
    Calendar calendar = Calendar.getInstance();
    SimpleDateFormat dateFormat = new SimpleDateFormat(RFC_1123_DATE, Locale.US);
    dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
    return dateFormat.format(calendar.getTime());
  }

  private static void postData(String signature, String dateString, String json) throws IOException {
    String url = "https://" + workspaceId + ".ods.opinsights.azure.com/api/logs?api-version=2016-04-01";
    HttpPost httpPost = new HttpPost(url);
    httpPost.setHeader("Authorization", signature);
    httpPost.setHeader(CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
    httpPost.setHeader("Log-Type", logName);
    httpPost.setHeader("x-ms-date", dateString);
    httpPost.setHeader("time-generated-field", timestamp);
    httpPost.setEntity(new StringEntity(json));
    try(CloseableHttpClient httpClient = HttpClients.createDefault()){
      HttpResponse response = httpClient.execute(httpPost);
      int statusCode = response.getStatusLine().getStatusCode();
      System.out.println("Status code: " + statusCode);
    }
  }

  private static String getHMAC256(String input, String key) throws InvalidKeyException, NoSuchAlgorithmException {
    String hash;
    Mac sha256HMAC = Mac.getInstance("HmacSHA256");
    Base64.Decoder decoder = Base64.getDecoder();
    SecretKeySpec secretKey = new SecretKeySpec(decoder.decode(key.getBytes(StandardCharsets.UTF_8)), "HmacSHA256");
    sha256HMAC.init(secretKey);
    Base64.Encoder encoder = Base64.getEncoder();
    hash = new String(encoder.encode(sha256HMAC.doFinal(input.getBytes(StandardCharsets.UTF_8))));
    return hash;
  }

}

Alternativen und Überlegungen

Obwohl die Datensammler-API die meisten Ihrer Anforderungen abdecken sollte, während Sie Freiformdaten in Azure-Protokolle sammeln, benötigen Sie möglicherweise einen alternativen Ansatz, um einige der Einschränkungen der API zu überwinden. Ihre Optionen, einschließlich wichtiger Überlegungen, sind in der folgenden Tabelle aufgeführt:

Alternative	Beschreibung	Am besten geeignet für
Benutzerdefinierte Ereignisse: Native SDK-basierte Erfassung in Application Insights	Application Insights, in der Regel über ein SDK in Ihrer Anwendung instrumentiert, bietet Ihnen die Möglichkeit, benutzerdefinierte Daten über benutzerdefinierte Ereignisse zu senden.	Daten, die in Ihrer Anwendung generiert werden, vom SDK jedoch nicht über einen der Standarddatentypen (Anforderungen, Abhängigkeiten, Ausnahmen usw.) erfasst werden. Daten, die am häufigsten mit anderen Anwendungsdaten in Application Insights korreliert sind.
Datensammler-API in Azure Monitor-Protokollen	Die Datensammler-API in Azure Monitor-Protokollen ist eine völlig offene Möglichkeit zum Aufnehmen von Daten. Alle Daten, die in einem JSON-Objekt formatiert sind, können hier gesendet werden. Nachdem sie gesendet wurde, wird sie verarbeitet und in Monitorprotokollen zur Verfügung gestellt, um mit anderen Daten in Monitorprotokollen oder mit anderen Application Insights-Daten korreliert zu werden. Es ist ziemlich einfach, die Daten als Dateien in ein Azure Blob Storage-Blob hochzuladen, in dem die Dateien verarbeitet und dann in Log Analytics hochgeladen werden. Eine Beispielimplementierung finden Sie unter Erstellen einer Datenpipeline mit der Datensammler-API.	Daten, die nicht unbedingt innerhalb einer Anwendung generiert werden, die in Application Insights instrumentiert ist. Beispiele sind Nachschlage- und Faktentabellen, Referenzdaten, voraggregierte Statistiken usw. Daten, die mit anderen Azure Monitor-Daten abgeglichen werden (Application Insights, andere Monitor-Logs-Datentypen, Defender für die Cloud, Container Insights und virtuelle Computer usw.).
Azure Data Explorer	Azure Data Explorer, der jetzt allgemein für die Öffentlichkeit verfügbar ist, ist die Datenplattform, die Application Insights Analytics und Azure Monitor Logs unterstützt. Durch die Nutzung der Datenplattform in ihrer Rohform haben Sie vollständige Flexibilität, erfordert jedoch den Verwaltungsaufwand über den Cluster; Kubernetes rollenbasierte Zugriffskontrolle (RBAC), Aufbewahrungsrate, Schema usw. Azure Data Explorer bietet viele Eingabeoptionen, einschließlich CSV-, TSV- und JSON-Dateien.	Daten, die nicht mit anderen Daten unter Application Insights oder Überwachungsprotokollen korreliert werden. Daten, die erweiterte Aufnahme- oder Verarbeitungsfunktionen erfordern, die heute in Azure Monitor-Protokollen nicht verfügbar sind.

Nächste Schritte

• Verwenden Sie die Protokollsuche-API, um Daten aus dem Log Analytics-Arbeitsbereich abzurufen.
• Erfahren Sie mehr darüber, wie Sie eine Datenpipeline mit der Datensammler-API erstellen, indem Sie einen Logic Apps-Workflow für Azure Monitor verwenden.