Senden von Protokolldaten an Azure Monitor mit der HTTP-Datensammler-API (Public Preview)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

In diesem Artikel wird gezeigt, wie Sie die HTTP-Datensammler-API verwenden, um Protokolldaten von einem REST-API-Client an Azure Monitor zu senden.This article shows you how to use the HTTP Data Collector API to send log data to Azure Monitor from a REST API client. Es wird beschrieben, wie die von Ihrem Skript oder Ihrer Anwendung gesammelten Daten formatiert und in eine Anforderung eingefügt werden müssen, um diese dann von Azure Monitor autorisieren zu lassen.It describes how to format data collected by your script or application, include it in a request, and have that request authorized by Azure Monitor. Die Beispiele werden für PowerShell, C# und Python angegeben.Examples are provided for PowerShell, C#, and Python.

Hinweis

Dieser Artikel wurde kürzlich aktualisiert, um den Begriff Azure Monitor-Protokolle anstelle von Log Analytics aufzunehmen.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Protokolldaten werden immer noch in einem Log Analytics-Arbeitsbereich gespeichert und weiterhin mit dem gleichen Log Analytics-Dienst erfasst und analysiert.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. Die Terminologie hat sich geändert, um der Rolle von Protokollen in Azure Monitor besser Rechnung zu tragen.We are updating the terminology to better reflect the role of logs in Azure Monitor. Weitere Informationen finden Sie unter Terminologieänderungen bei Azure Monitor.See Azure Monitor terminology changes for details.

Hinweis

Die HTTP-Datensammler-API von Azure Monitor befindet sich in der Phase „Public Preview“.The Azure Monitor HTTP Data Collector API is in public preview.

KonzepteConcepts

Mit der HTTP-Datensammler-API können Sie einem Log Analytics-Arbeitsbereich in Azure Monitor über jeden Client, der eine REST-API aufrufen kann, Protokolldaten senden.You can use the HTTP Data Collector API to send log data to a Log Analytics workspace in Azure Monitor from any client that can call a REST API. Dabei kann es sich um ein Runbook in Azure Automation handeln, das Verwaltungsdaten aus Azure oder einer anderen Cloud sammelt, oder ein anderes Verwaltungssystem, das Azure Monitor zum Konsolidieren und Analysieren von Protokolldaten verwendet.This might be a runbook in Azure Automation that collects management data from Azure or another cloud, or it might be an alternate management system that uses Azure Monitor to consolidate and analyze log data.

Alle Daten im Log Analytics-Arbeitsbereich werden als Datensätze mit einem bestimmten Datensatztyp gespeichert.All data in the Log Analytics workspace is stored as a record with a particular record type. Formatieren Sie die Daten für das Senden die HTTP-Datensammler-API als mehrere Datensätze im JSON-Format.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Wenn Sie die Daten übermitteln, wird ein einzelner Datensatz im Repository für jeden Datensatz in der Anforderungsnutzlast erstellt.When you submit the data, an individual record is created in the repository for each record in the request payload.

Übersicht über die HTTP-Datensammler-API

Erstellen einer AnforderungCreate a request

Um die HTTP-Datensammler-API zu verwenden, erstellen Sie eine POST-Anforderung mit den zu sendenden Daten in JavaScript Object Notation (JSON).To use the HTTP Data Collector API, you create a POST request that includes the data to send in JavaScript Object Notation (JSON). Die nächsten drei Tabellen enthalten die Attribute, die für die einzelnen Anforderungen erforderlich sind.The next three tables list the attributes that are required for each request. Jedes Attribut wird weiter unten in diesem Artikel ausführlicher beschrieben.We describe each attribute in more detail later in the article.

Anforderungs-URIRequest URI

attributeAttribute EigenschaftProperty
MethodeMethod POSTPOST
URIURI https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01
InhaltstypContent type Anwendung/jsonapplication/json

URI-Parameter der AnforderungRequest URI parameters

ParameterParameter BESCHREIBUNGDescription
CustomerIDCustomerID Eindeutiger Bezeichner für den Log Analytics-ArbeitsbereichThe unique identifier for the Log Analytics workspace.
ResourceResource Der Name der API-Ressource: /api/logsThe API resource name: /api/logs.
API-VersionAPI Version Die Version der bei dieser Anforderung verwendeten API.The version of the API to use with this request. Die aktuelle Version lautet 2016-04-01.Currently, it's 2016-04-01.

AnforderungsheaderRequest headers

HeaderHeader BESCHREIBUNGDescription
AuthorizationAuthorization Die Signatur der Autorisierung.The authorization signature. Weiter unten in diesem Artikel erhalten Sie Informationen zum Erstellen eines HMAC-SHA256-Headers.Later in the article, you can read about how to create an HMAC-SHA256 header.
Log-TypeLog-Type Geben Sie den Datensatztyp der übermittelten Daten an.Specify the record type of the data that is being submitted. Darf nur Buchstaben, Ziffern und Unterstriche () sowie höchstens 100 Zeichen enthalten.Can only contain letters, numbers, and underscore (), and may not exceed 100 characters.
x-ms-datex-ms-date Das Datum, zu dem die Anforderung verarbeitet wurde, im RFC 1123-FormatThe date that the request was processed, in RFC 1123 format.
x-ms-AzureResourceIdx-ms-AzureResourceId Ressourcen-ID der Azure-Ressource, der die Daten zugeordnet werden sollen.Resource ID of the Azure resource the data should be associated with. Dadurch wird die Eigenschaft _ResourceId ausgefüllt, und es werden die Daten zugelassen, die in resource-context-Abfragen einbezogen werden sollen.This populates the _ResourceId property and allows the data to be included in resource-context queries. Wenn dieses Feld nicht angegeben wird, werden die Daten nicht in „resource-context“-Abfragen einbezogen.If this field isn't specified, the data will not be included in resource-context queries.
time-generated-fieldtime-generated-field Der Name eines Felds in den Daten, das den Zeitstempel des Datenelements enthält.The name of a field in the data that contains the timestamp of the data item. Wenn Sie ein Feld angeben, wird dessen Inhalt für TimeGenerated verwendet.If you specify a field then its contents are used for TimeGenerated. Wenn dieses Feld nicht angegeben wurde, ist der Standardwert für TimeGenerated die Zeit, zu der die Nachricht erfasst wurde.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. Der Inhalt des Nachrichtenfelds sollte das ISO 8601-Format (jjjj-mm-ttThh:mm:ssZ) einhalten.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AuthorizationAuthorization

Jede Anforderung an die HTTP-Datensammler-API von Azure Monitor muss einen „Authorization“-Header enthalten.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Um eine Anforderung zu authentifizieren, müssen Sie die Anforderung mit dem primären oder sekundären Schlüssel für den Arbeitsbereich, der die Anforderung gesendet hat, signieren.To authenticate a request, you must sign the request with either the primary or the secondary key for the workspace that is making the request. Übergeben Sie anschließend diese Signatur als Teil der Anforderung.Then, pass that signature as part of the request.

Dies ist das Format für den „Authorization“-Header:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID ist der eindeutige Bezeichner des Log Analytics-Arbeitsbereichs.WorkspaceID is the unique identifier for the Log Analytics workspace. Die Signatur ist ein HMAC (Hash-based Message Authentication Code), der aus der Anforderung erstellt und dann mit dem SHA256-Algorithmus berechnet wird.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Anschließend codieren Sie ihn mit der Base64-Codierung.Then, you encode it by using Base64 encoding.

Verwenden Sie dieses Format zum Codieren der SharedKey-Signaturzeichenfolge:Use this format to encode the SharedKey signature string:

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

Dies ist ein Beispiel für eine Signaturzeichenfolge:Here's an example of a signature string:

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

Codieren Sie anschließend die Signaturzeichenfolge, indem Sie den HMAC-SHA256-Algorithmus auf die UTF-8-codierte Zeichenfolge anwenden und dann das Ergebnis als Base64 codieren.When you have the signature string, encode it by using the HMAC-SHA256 algorithm on the UTF-8-encoded string, and then encode the result as Base64. Verwenden Sie dieses Format:Use this format:

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

Die Beispiele in den nächsten Abschnitten enthalten Beispielcode, den Sie zum Erstellen eines „Authorization“-Headers verwenden können.The samples in the next sections have sample code to help you create an authorization header.

AnforderungstextRequest body

Der Text der Nachricht muss das JSON-Format aufweisen.The body of the message must be in JSON. Er muss einen oder mehrere Datensätze mit Paaren aus Eigenschaftenname und -wert in im folgenden Format enthalten.It must include one or more records with the property name and value pairs in the following format. Der Eigenschaftsname darf nur Buchstaben, Ziffern und Unterstriche () enthalten.The property name can only contain letters, numbers, and underscore ().

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

Sie können mehrere Datensätze in einem Anforderungsbatch zusammenfassen. Verwenden Sie dazu das folgende Format.You can batch multiple records together in a single request by using the following format. Alle Datensätze müssen denselben Datensatztyp aufweisen.All the records must be the same record type.

[
    {
        "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 EigenschaftenRecord type and properties

Sie definieren einen benutzerdefinierten Datensatztyp beim Senden von Daten über die HTTP-Datensammler-API von Azure Monitor.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. Derzeit können Sie keine Daten in vorhandene Datensatztypen schreiben, die von anderen Datentypen und Lösungen erstellt wurden.Currently, you can't write data to existing record types that were created by other data types and solutions. Azure Monitor liest die eingehenden Daten und erstellt dann die Eigenschaften, die den Datentypen der eingegebenen Werte entsprechen.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Jede Anforderung an die Datensammler-API muss einen Log-Type-Header mit dem Namen für den Datensatztyp enthalten.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Das Suffix _CL wird automatisch an den eingegebenen Namen angefügt, um es von anderen Protokolltypen wie z.B. benutzerdefinierten Protokollen zu unterscheiden.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Wenn Sie beispielsweise den Namen MyNewRecordType eingeben, erstellt Azure Monitor einen Datensatz vom Typ MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. Dadurch wird sichergestellt, dass keine Konflikte zwischen benutzerdefinierten Typnamen und den im Lieferumfang von aktuellen oder zukünftiger Microsoft-Lösungen enthaltenen Typen auftreten.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Um den Datentyp einer Eigenschaft festzulegen, fügt Azure Monitor ein Suffix an den Eigenschaftennamen an.To identify a property's data type, Azure Monitor adds a suffix to the property name. Wenn eine Eigenschaft einen NULL-Wert enthält, ist die Eigenschaft nicht in diesem Datensatz enthalten.If a property contains a null value, the property is not included in that record. Diese Tabelle enthält den Datentyp der Eigenschaft und das entsprechende Suffix:This table lists the property data type and corresponding suffix:

Datentyp der EigenschaftProperty data type SuffixSuffix
StringString _s_s
BooleanBoolean _b_b
DoubleDouble _d_d
Datum/UhrzeitDate/time _t_t
GUID (als Zeichenfolge gespeichert)GUID (stored as a string) _g_g

Hinweis

Zeichenfolgenwerte, die als GUIDs erscheinen, erhalten das Suffix „_g“und werden als GUID formatiert, auch wenn der eingehende Wert keine Bindestriche enthält.String values that appear to be GUIDs will be given the _g suffix and formatted as a GUID, even if the incoming value doesn't include dashes. Beispielsweise werden sowohl „8145d822-13a7-44ad-859c-36f31a84f6dd“ als auch „8145d82213a744ad859c36f31a84f6dd“ als „8145d822-13a7-44ad-859c-36f31a84f6dd“ gespeichert.For example, both "8145d822-13a7-44ad-859c-36f31a84f6dd" and "8145d82213a744ad859c36f31a84f6dd" will be stored as "8145d822-13a7-44ad-859c-36f31a84f6dd". Die einzigen Unterschiede zwischen dieser und einer anderen Zeichenfolge ist das „_g“ im Namen und das Einfügen von Bindestrichen, wenn diese nicht in der Eingabe enthalten sind.The only differences between this and another string is the _g in the name and the insertion of dashes if they aren't provided in the input.

Der Datentyp, den Azure Monitor für die einzelnen Eigenschaften verwendet, hängt davon ab, ob der Datensatztyp für den neuen Datensatz bereits vorhanden ist.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Wenn der Datensatztyp nicht vorhanden ist, erstellt Azure Monitor einen neuen und verwendet dabei den JSON-Typrückschluss, um den Datentyp für die einzelnen Eigenschaften des neuen Datensatzes zu ermitteln.If the record type does not exist, Azure Monitor creates a new one using the JSON type inference to determine the data type for each property for the new record.
  • Wenn der Datensatztyp vorhanden ist, erstellt Azure Monitor einen neuen Datensatz basierend auf vorhandenen Eigenschaften.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. 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 nicht vorhandene Eigenschaft enthält, erstellt Azure Monitor eine neue Eigenschaft mit dem relevanten Suffix.If the data type for a property in the new record doesn’t match and can’t be converted to the existing type, or if the record includes a property that doesn’t exist, Azure Monitor creates a new property that has the relevant suffix.

Bei diesem Übermittlungseintrag würde beispielsweise ein Datensatz mit den drei Eigenschaften number_d, boolean_b und string_s erstellt werden:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Beispieldatensatz 1

Wenn Sie dann den folgenden Eintrag übermitteln, bei dem alle Werte als Zeichenfolgen formatiert sind, werden die Eigenschaften nicht geändert.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Diese Werte können in vorhandene Datentypen konvertiert werden:These values can be converted to existing data types:

Beispieldatensatz 2

Wenn Sie dann aber diese weitere Übermittlung durchführen, erstellt Azure Monitor die neuen Eigenschaften boolean_d und string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Diese Werte können nicht konvertiert werden:These values can't be converted:

Beispieldatensatz 3

Wenn Sie dann den folgenden Eintrag übermitteln, bevor der Datensatztyp erstellt wurde, erstellt Azure Monitor einen Datensatz mit den drei Eigenschaften number_s, boolean_s und string_s.If you then submitted the following entry, before the record type was created, Azure Monitor would create a record with three properties, number_s, boolean_s, and string_s. In diesem Eintrag sind alle Anfangswerte als Zeichenfolge formatiert:In this entry, each of the initial values is formatted as a string:

Beispieldatensatz 4

Reservierte EigenschaftenReserved properties

Die folgenden Eigenschaften sind reserviert und sollten nicht in einem benutzerdefinierten Datensatztyp verwendet werden.The following properties are reserved and should not be used in a custom record type. Es wird ein Fehler angezeigt, wenn Ihre Nutzlast einen dieser Eigenschaftennamen enthält.You will receive an error if your payload includes any of these property names.

  • tenanttenant

DatengrenzwerteData limits

Für die Daten, die an die Datensammlungs-API von Azure Monitor gesendet werden, gelten einige Einschränkungen.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Maximal 30 MB pro Sendung an die Datensammlungs-API von Azure Monitor.Maximum of 30 MB per post to Azure Monitor Data Collector API. Diese Größenbeschränkung gilt für eine einzelne Sendung.This is a size limit for a single post. Wenn eine einzelne Sendung mehr als 30 MB Daten enthält, teilen Sie die Daten auf, und senden Sie kleinere Datenblöcke gleichzeitig.If the data from a single post that exceeds 30 MB, you should split the data up to smaller sized chunks and send them concurrently.
  • Maximal 32 KB für Feldwerte.Maximum of 32 KB limit for field values. Wenn ein Feldwert größer ist als 32 KB, werden die Daten abgeschnitten.If the field value is greater than 32 KB, the data will be truncated.
  • Die empfohlene maximale Anzahl von Feldern eines bestimmten Typs beträgt 50.Recommended maximum number of fields for a given type is 50. Dies ist aus Sicht der Benutzerfreundlichkeit und Suchleistung ein praktikabler Wert.This is a practical limit from a usability and search experience perspective.
  • Eine Tabelle in einem Log Analytics-Arbeitsbereich unterstützt nur bis zu 500 Spalten (in diesem Artikel als ein Feld bezeichnet).A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Die maximale Anzahl von Zeichen für den Spaltennamen ist 500.The maximum number of characters for the column name is 500.

RückgabecodesReturn codes

Der HTTP-Statuscode 200 bedeutet, dass die Anforderung für die Verarbeitung empfangen wurde.The HTTP status code 200 means that the request has been received for processing. Dies gibt an, dass der Vorgang erfolgreich abgeschlossen wurde.This indicates that the operation completed successfully.

Diese Tabelle enthält den vollständigen Satz von Statuscodes, die vom Dienst zurückgegeben werden können:This table lists the complete set of status codes that the service might return:

CodeCode StatusStatus FehlercodeError code BESCHREIBUNGDescription
200200 OKOK Die Anforderung wurde erfolgreich angenommen.The request was successfully accepted.
400400 Ungültige AnforderungBad request InactiveCustomerInactiveCustomer Der Arbeitsbereich wurde geschlossen.The workspace has been closed.
400400 Ungültige AnforderungBad request InvalidApiVersionInvalidApiVersion Die angegebene API-Version wurde vom Dienst nicht erkannt.The API version that you specified was not recognized by the service.
400400 Ungültige AnforderungBad request InvalidCustomerIdInvalidCustomerId Die angegebene Arbeitsbereichs-ID ist ungültig.The workspace ID specified is invalid.
400400 Ungültige AnforderungBad request InvalidDataFormatInvalidDataFormat Es wurde ein ungültiges JSON-Format übermittelt.Invalid JSON was submitted. Der Antworttext enthält eventuell weitere Informationen zum Beheben des Fehlers.The response body might contain more information about how to resolve the error.
400400 Ungültige AnforderungBad request InvalidLogTypeInvalidLogType Der angegebene Protokolltyp enthält Sonderzeichen oder Ziffern.The log type specified contained special characters or numerics.
400400 Ungültige AnforderungBad request MissingApiVersionMissingApiVersion Die API-Version wurde nicht angegeben.The API version wasn’t specified.
400400 Ungültige AnforderungBad request MissingContentTypeMissingContentType Der Inhaltstyp wurde nicht angegeben.The content type wasn’t specified.
400400 Ungültige AnforderungBad request MissingLogTypeMissingLogType Der erforderliche Protokolltyp für den Wert wurde nicht angegeben.The required value log type wasn’t specified.
400400 Ungültige AnforderungBad request UnsupportedContentTypeUnsupportedContentType Der Inhaltstyp wurde nicht auf application/json festgelegt.The content type was not set to application/json.
403403 VerbotenForbidden InvalidAuthorizationInvalidAuthorization Der Dienst konnte die Anforderung nicht authentifizieren.The service failed to authenticate the request. Vergewissern Sie sich, dass die Arbeitsbereichs-ID und der Verbindungsschlüssel gültig sind.Verify that the workspace ID and connection key are valid.
404404 Nicht gefundenNot Found Die angegebene URL ist falsch, oder die Anforderung ist zu groß.Either the URL provided is incorrect, or the request is too large.
429429 Zu viele AnforderungenToo Many Requests Der Dienst erwartet eine große Datenmenge von Ihrem Konto.The service is experiencing a high volume of data from your account. Versuchen Sie die Anforderung später erneut.Please retry the request later.
500500 Interner ServerfehlerInternal Server Error UnspecifiedErrorUnspecifiedError Auf dem Server wurde ein interner Fehler festgestellt.The service encountered an internal error. Versuchen Sie die Anforderung erneut.Please retry the request.
503503 Dienst nicht verfügbarService Unavailable ServiceUnavailableServiceUnavailable Der Dienst kann derzeit keine Anforderungen empfangen.The service currently is unavailable to receive requests. Bitte wiederholen Sie die Anforderung.Please retry your request.

Daten abfragenQuery data

Zum Abfragen von Daten, die über die HTTP-Datensammler-API von Azure Monitor übermittelt wurden, suchen Sie nach Datensätzen mit einem Typ, der dem von Ihnen angegebenen LogType-Wert entspricht, und dem Suffix _CL.To query data submitted by the Azure Monitor HTTP Data Collector API, search for records with Type that is equal to the LogType value that you specified, appended with _CL. Wenn Sie z.B. MyCustomLog verwendet haben, werden alle Datensätze mit MyCustomLog_CL zurückgegeben.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

BeispielanforderungenSample requests

In den nächsten Abschnitten finden Sie Beispiele für das Senden von Daten an die HTTP-Datensammler-API von Azure Monitor in verschiedenen Programmiersprachen.In the next sections, you'll find samples of how to submit data to the Azure Monitor HTTP Data Collector API by using different programming languages.

Führen Sie für alle Beispiele folgende Schritte aus, um die Variablen für den „Authorization“-Header festzulegen:For each sample, do these steps to set the variables for the authorization header:

  1. Suchen Sie im Azure-Portal Ihren Log Analytics-Arbeitsbereich.In the Azure portal, locate your Log Analytics workspace.
  2. Wählen Sie Agent-Verwaltung aus.Select Agents management.
  3. Wählen Sie rechts neben Arbeitsbereichs-ID das Symbol „Kopieren“ aus, und fügen Sie die ID als Wert der Variablen für die Kunden-ID ein.To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. Wählen Sie rechts neben Primärschlüssel das Symbol „Kopieren“ aus, und fügen Sie die ID als Wert der Variablen für den gemeinsam verwendeten Schlüssel ein.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

Sie können auch die Variablen für den Protokolltyp und die JSON-Daten ändern.Alternatively, you can change the variables for the log type and JSON data.

PowerShell-BeispielPowerShell sample

# 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"

# 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
$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#-BeispielC# sample

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

                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 2-BeispielPython 2 sample

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).encode('utf-8')  
    decoded_key = base64.b64decode(shared_key)
    encoded_hash = base64.b64encode(hmac.new(decoded_key, bytes_to_hash, digestmod=hashlib.sha256).digest())
    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)

Python 3-BeispielPython 3 sample

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-BeispielJava sample


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 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 = getHMAC254(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);
    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 getHMAC254(String input, String key) throws InvalidKeyException, NoSuchAlgorithmException {
    String hash;
    Mac sha254HMAC = Mac.getInstance("HmacSHA256");
    Base64.Decoder decoder = Base64.getDecoder();
    SecretKeySpec secretKey = new SecretKeySpec(decoder.decode(key.getBytes(StandardCharsets.UTF_8)), "HmacSHA256");
    sha254HMAC.init(secretKey);
    Base64.Encoder encoder = Base64.getEncoder();
    hash = new String(encoder.encode(sha254HMAC.doFinal(input.getBytes(StandardCharsets.UTF_8))));
    return hash;
  }

}


Alternativen und ÜberlegungenAlternatives and considerations

Während die Datensammler-API die meisten Ihrer Anforderungen an die Erfassung von Freiformdaten in Azure-Protokollen erfüllen sollte, gibt es Fälle, in denen eine Alternative erforderlich sein könnte, um einige der Einschränkungen der API zu umgehen.While the Data Collector API should cover most of your needs to collect free-form data into Azure Logs, there are instances where an alternative might be required to overcome some of the limitations of the API. Es gibt folgende Optionen, einschließlich der wichtigsten Überlegungen:All your options are as follows, major considerations included:

AlternativeAlternative BESCHREIBUNGDescription Am besten geeignet fürBest suited for
Benutzerdefinierte Ereignisse: Native SDK-basierte Erfassung in Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, das in der Regel über ein SDK in Ihrer Anwendung instrumentiert wird, bietet die Möglichkeit, benutzerdefinierte Daten über benutzerdefinierte Ereignisse zu senden.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Daten, die innerhalb Ihrer Anwendung erzeugt, aber nicht vom SDK über einen der Standarddatentypen (Anforderungen, Abhängigkeiten, Ausnahmen usw.) abgeholt werden.Data that is generated within your application, but not picked up by SDK through one of the default data types (requests, dependencies, exceptions, and so on).
  • Daten, die am häufigsten mit anderen Anwendungsdaten in Application Insights korreliert werdenData that is most often correlated to other application data in Application Insights
Datensammler-API in Azure Monitor-ProtokollenData Collector API in Azure Monitor Logs Die Datensammler-API in Azure Monitor-Protokollen ist eine völlig offene Methode zur Datenerfassung.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Alle in einem JSON-Objekt formatierten Daten können hier gesendet werden.Any data formatted in a JSON object can be sent here. Nachdem sie gesendet wurden, werden sie verarbeitet und stehen in Protokollen zur Verfügung, um mit anderen Daten in Protokollen oder mit anderen Application Insights-Daten korreliert zu werden.Once sent, it will be processed, and available in Logs to be correlated with other data in Logs or against other Application Insights data.

Es ist ziemlich einfach, die Daten als Dateien auf einen Azure Blob-Blob hochzuladen, von wo aus diese Dateien verarbeitet und an Log Analytics hochgeladen werden.It is fairly easy to upload the data as files to an Azure Blob blob, from where these files will be processed and uploaded to Log Analytics. Eine Beispielimplementierung einer derartigen Pipeline finden Sie in diesem Artikel.Please see this article for a sample implementation of such a pipeline.
  • Daten, die nicht notwendigerweise innerhalb einer Anwendung generiert werden, die innerhalb von Application Insights instrumentiert wird.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Beispiele sind Lookup- und Faktentabellen, Referenzdaten, vorab aggregierte Statistiken usw.Examples include lookup and fact tables, reference data, pre-aggregated statistics, and so on.
  • Vorgesehen für Daten, auf die mit anderen Azure Monitor-Daten über Querverweise verwiesen wird (Application Insights, andere Protokolldatentypen, Security Center, Azure Monitor für Container/VMs usw.).Intended for data that will be cross-referenced against other Azure Monitor data (Application Insights, other Logs data types, Security Center, Azure Monitor for Containers/VMs, and so on).
Azure Data ExplorerAzure Data Explorer Azure Data Explorer (ADX) ist die Datenplattform, die Application Insights Analytics und Azure Monitor Logs unterstützt.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Jetzt „allgemein verfügbar“ (GA): Die Verwendung der Datenplattform im Rohformat bietet Ihnen die volle Flexibilität (erfordert aber den Verwaltungsmehraufwand) über den Cluster (RBAC, Bindungsrate, Schema usw.).Now Generally Available ("GA"), using the data platform in its raw form provides you complete flexibility (but requiring the overhead of management) over the cluster (RBAC, retention rate, schema, and so on). ADX bietet viele Erfassungsoptionen einschließlich CSV-, TSV- und JSON-Dateien.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Daten, die nicht mit anderen Daten unter Application Insights oder in Protokollen korreliert werden.Data that will not be correlated to any other data under Application Insights or Logs.
  • Daten, die erweiterte Erfassungs- oder Verarbeitungsfunktionen erfordern, die heute nicht in Azure Monitor Logs verfügbar sind.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Nächste SchritteNext steps