Senden von Daten an Log Analytics mit der HTTP-Datensammler-API (Public Preview)Send data to Log Analytics with the HTTP Data Collector API (public preview)

In diesem Artikel wird gezeigt, wie Sie die HTTP-Datensammler-API verwenden, um Daten von einem REST-API-Client an Log Analytics zu senden.This article shows you how to use the HTTP Data Collector API to send data to Log Analytics 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 Log Analytics 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 Log Analytics. Die Beispiele werden für PowerShell, C# und Python angegeben.Examples are provided for PowerShell, C#, and Python.

Hinweis

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

KonzepteConcepts

Sie können die HTTP-Datensammler-API verwenden, um Daten von einem Client, der die REST-API aufrufen kann, an Log Analytics zu senden.You can use the HTTP Data Collector API to send data to Log Analytics 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 Log Analytics zum Konsolidieren und Analysieren von Daten 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 Log Analytics to consolidate and analyze data.

Alle Daten im Log Analytics-Repository werden als Datensätze mit einem bestimmten Datensatztyp gespeichert.All data in the Log Analytics repository 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

AttributAttribute 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
Content-TypContent type Anwendung/jsonapplication/json

URI-Parameter der AnforderungRequest URI parameters

ParameterParameter BESCHREIBUNGDescription
CustomerIDCustomerID Der eindeutige Bezeichner für den Microsoft Operations Management Suite-ArbeitsbereichThe unique identifier for the Microsoft Operations Management Suite workspace.
RessourceResource 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
AutorisierungAuthorization 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. Zurzeit unterstützt der Protokolltyp nur Buchstaben.Currently, the log type supports only alpha characters. Ziffern oder Sonderzeichen werden nicht unterstützt.It does not support numerics or special 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.
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.

AutorisierungAuthorization

Jede Anforderung an die HTTP-Datensammler-API von Log Analytics muss einen „Authorization“-Header enthalten.Any request to the Log Analytics 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>

Die WorkspaceID ist der eindeutige Bezeichner für den Operations Management Suite-Arbeitsbereich.WorkspaceID is the unique identifier for the Operations Management Suite 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 diesem Format enthalten:It must include one or more records with the property name and value pairs in this format:

{
"property1": "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.

{
"property1": "value1",
" property 2": "value2"
" property 3": "value3",
" property 4": "value4"
},
{
"property1": "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 Log Analytics.You define a custom record type when you submit data through the Log Analytics 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. Log Analytics liest die eingehenden Daten und erstellt dann die Eigenschaften, die den Datentypen der eingegebenen Werte entsprechen.Log Analytics reads the incoming data and then creates properties that match the data types of the values that you enter.

Jede Anforderung an die Log Analytics-API muss einen Log-Type-Header mit dem Namen für den Datensatztyp enthalten.Each request to the Log Analytics 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 Log Analytics einen Datensatz vom Typ MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Log Analytics 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 Log Analytics ein Suffix an den Eigenschaftennamen an.To identify a property's data type, Log Analytics 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
ZeichenfolgeString _s_s
Boolescher WertBoolean _b_b
DoubleDouble _d_d
Datum/UhrzeitDate/time _t_t
GUIDGUID _g_g

Der Datentyp, den Log Analytics 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 Log Analytics uses for each property depends on whether the record type for the new record already exists.

  • Wenn der Datensatztyp noch nicht vorhanden ist, erstellt Log Analytics einen neuen.If the record type does not exist, Log Analytics creates a new one. Log Analytics verwendet den JSON-Typrückschluss, um den Datentyp für die einzelnen Eigenschaften des neuen Datensatzes zu ermitteln.Log Analytics uses the JSON type inference to determine the data type for each property for the new record.
  • Wenn der Datensatztyp vorhanden ist, erstellt Log Analytics einen neuen Datensatz basierend auf vorhandenen Eigenschaften.If the record type does exist, Log Analytics 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 Log Analytics 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, Log Analytics 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 Log Analytics die neuen Eigenschaften boolean_d und string_d.But, if you then made this next submission, Log Analytics 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, würde Log Analytics einen Datensatz mit den drei Eigenschaften number_s, boolean_s und string_s erstellen.If you then submitted the following entry, before the record type was created, Log Analytics 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

DatengrenzwerteData limits

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

  • Maximal 30 MB pro Sendung an die Datensammlungs-API von Log Analytics.Maximum of 30 MB per post to Log Analytics 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.

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.

Abfragen von DatenQuery data

Zum Abfragen von Daten, die über die HTTP-Datensammler-API von Log Analytics ü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 Log Analytics 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 Type=MyCustomLog_CL zurückgegeben.For example, if you used MyCustomLog, then you'd return all records with Type=MyCustomLog_CL.

Hinweis

Wenn für Ihren Arbeitsbereich ein Upgrade auf die neue Log Analytics-Abfragesprache durchgeführt wurde, muss die obige Abfrage wie folgt geändert werden.If your workspace has been upgraded to the new Log Analytics query language, then the above query would change to the following.

MyCustomLog_CL

BeispielanforderungenSample requests

In den nächsten Abschnitten finden Sie Beispiele für das Senden von Daten an die HTTP-Datensammler-API von Log Analytics in verschiedenen Programmiersprachen.In the next sections, you'll find samples of how to submit data to the Log Analytics 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. Wählen Sie im Operations Management Suite-Portal die Kachel Einstellungen und dann die Registerkarte Verbundene Quellen aus.In the Operations Management Suite portal, select the Settings tile, and then select the Connected Sources tab.
  2. 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.
  3. 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"

# Specify a field with the created time for the records
$TimeStampField = "DateValue"


# Create two records with the same set of properties to create
$json = @"
[{  "StringValue": "MyString1",
    "NumberValue": 42,
    "BooleanValue": true,
    "DateValue": "2016-05-12T20:00:00.625Z",
    "GUIDValue": "9909ED01-A74C-4874-8ABF-D2678E3AE23D"
},
{   "StringValue": "MyString2",
    "NumberValue": 43,
    "BooleanValue": false,
    "DateValue": "2016-05-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 `
        -fileName $fileName `
        -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 Operations Management Suite 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 Log Analytics
        static string LogName = "DemoExample";

        // You can use an optional field to specify the timestamp from the data. If the time field is not specified, Log Analytics 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(message);
            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-BeispielPython sample

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

# Update the customer ID to your Operations Management Suite 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)

Nächste SchritteNext steps

  • Verwenden Sie zum Abrufen von Daten aus dem Log Analytics-Repository die Protokollsuch-API.Use the Log Search API to retrieve data from the Log Analytics repository.