Logboekgegevens verzenden naar Azure Monitor met de HTTP Data Collector-API (preview-versie)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

Dit artikel leest u hoe de API HTTP Data Collector gebruikt om te verzenden van logboekgegevens naar Azure Monitor van een REST-API-client.This article shows you how to use the HTTP Data Collector API to send log data to Azure Monitor from a REST API client. Dit wordt beschreven hoe u gegevens die zijn verzameld door het script of een toepassing opmaken, opnemen in een aanvraag en die aanvraag heeft geautoriseerd door Azure Monitor.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. Voorbeelden zijn bedoeld voor PowerShell, C# en Python.Examples are provided for PowerShell, C#, and Python.

Notitie

In dit artikel is onlangs bijgewerkt voor de term logboeken van Azure Monitor gebruiken in plaats van Log Analytics.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Logboekgegevens is nog steeds wordt opgeslagen in een Log Analytics-werkruimte en nog steeds verzameld en geanalyseerd door de dezelfde Log Analytics-service.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. We bij het bijwerken van de terminologie beter aan de rol van registreert in Azure Monitor.We are updating the terminology to better reflect the role of logs in Azure Monitor. Zie Azure Monitor-terminologie wijzigingen voor meer informatie.See Azure Monitor terminology changes for details.

Notitie

De API van Azure Monitor HTTP Data Collector is in openbare preview.The Azure Monitor HTTP Data Collector API is in public preview.

ConceptenConcepts

De HTTP Data Collector-API kunt u logboekgegevens naar een Log Analytics-werkruimte in Azure Monitor verzenden vanaf een willekeurige client die een REST-API kunt aanroepen.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. Dit wordt mogelijk een runbook in Azure Automation die management verzamelt mogelijk gegevens vanuit Azure of een andere cloud, of het een ander beheersysteem die gebruikmaakt van Azure Monitor om te consolideren en analyseren van logboekgegevens.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 gegevens in de Log Analytics-werkruimte wordt opgeslagen als een record met een bepaald type.All data in the Log Analytics workspace is stored as a record with a particular record type. U uw gegevens worden verzonden naar de API HTTP Data Collector als meerdere records in de JSON-indeling.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Wanneer u de gegevens hebt ingediend, wordt een afzonderlijke record gemaakt in de opslagplaats voor elke record in de nettolading van de aanvraag.When you submit the data, an individual record is created in the repository for each record in the request payload.

Overzicht van de HTTP-gegevensverzamelaar

Een aanvraag makenCreate a request

Voor het gebruik van de API HTTP Data Collector, maakt u een POST-aanvraag met de gegevens worden verzonden 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). De volgende drie tabellen worden de kenmerken die vereist voor elke aanvraag zijn.The next three tables list the attributes that are required for each request. Elk kenmerk in meer detail later in dit artikel wordt beschreven.We describe each attribute in more detail later in the article.

Aanvraag-URIRequest URI

KenmerkAttribute EigenschapProperty
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
Type inhoudContent type application/jsonapplication/json

Aanvraag-URI-parametersRequest URI parameters

ParameterParameter DescriptionDescription
CustomerIDCustomerID De unieke id voor de Log Analytics-werkruimte.The unique identifier for the Log Analytics workspace.
ResourceResource De naam van de API-resource: / api/logs.The API resource name: /api/logs.
API-versieAPI Version De versie van de API voor gebruik met deze aanvraag.The version of the API to use with this request. Het is momenteel, 2016-04-01.Currently, it's 2016-04-01.

AanvraagheadersRequest headers

HeaderHeader DescriptionDescription
AutorisatieAuthorization De autorisatie-handtekening.The authorization signature. Later in dit artikel, kunt u lezen over het maken van een HMAC-SHA256-header.Later in the article, you can read about how to create an HMAC-SHA256 header.
Log-TypeLog-Type Geef het recordtype van de gegevens die wordt verzonden.Specify the record type of the data that is being submitted. De maximale grootte voor deze parameter is 100 tekens.The size limit for this parameter is 100 characters.
x-ms-datex-ms-date De datum waarop de aanvraag is verwerkt, in de RFC 1123-indeling.The date that the request was processed, in RFC 1123 format.
x-ms-AzureResourceIdx-ms-AzureResourceId Resource-ID van de Azure-resource de gegevens moet worden gekoppeld.Resource ID of the Azure resource the data should be associated with. Dit vult de _ResourceId eigenschap en maakt het mogelijk de gegevens moeten worden opgenomen in resource-georiënteerde query's.This populates the _ResourceId property and allows the data to be included in resource-centric queries. Als dit veld niet wordt opgegeven, worden de gegevens niet worden opgenomen in de resource-georiënteerde query's.If this field isn't specified, the data will not be included in resource-centric queries.
Time-gegenereerd-veldtime-generated-field De naam van een veld in de gegevens die met het tijdstempel van het gegevensitem.The name of a field in the data that contains the timestamp of the data item. Als u een veld opgeven en vervolgens de inhoud ervan worden gebruikt voor TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Als dit veld niet wordt opgegeven, de standaardwaarde voor TimeGenerated is de tijd die het bericht wordt opgenomen.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. De inhoud van het berichtenveld diende de ISO 8601-notatie jjjj-MM-ddTHH.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AutorisatieAuthorization

Elk verzoek aan de API van Azure Monitor HTTP Data Collector moet een autorisatie-header bevatten.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Als u wilt een aanvraag worden geverifieerd, moet u zich aanmelden met de aanvraag met de primaire of de secundaire sleutel voor de werkruimte die de aanvraag wordt uitgevoerd.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. Geeft de handtekening die als onderdeel van de aanvraag.Then, pass that signature as part of the request.

Hier volgt de indeling voor de autorisatie-header:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

Werkruimte-id is de unieke id voor de Log Analytics-werkruimte.WorkspaceID is the unique identifier for the Log Analytics workspace. Handtekening is een HMAC Hash-based Message Authentication Code () die is samengesteld uit de aanvraag en vervolgens worden berekend met behulp van de algoritme SHA256.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Klik, codeert u deze met behulp van Base64-codering.Then, you encode it by using Base64 encoding.

Deze indeling gebruiken om te coderen de SharedKey handtekening tekenreeks:Use this format to encode the SharedKey signature string:

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

Hier volgt een voorbeeld van een handtekening-tekenreeks: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

Wanneer u de handtekening-tekenreeks hebt, deze met behulp van de HMAC-SHA256-algoritme op de UTF-8-gecodeerde tekenreeks te coderen en vervolgens het resultaat als Base64 coderen.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. Gebruik deze indeling:Use this format:

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

De voorbeelden in de volgende secties hebben voorbeeldcode voor het maken van een autorisatie-header.The samples in the next sections have sample code to help you create an authorization header.

AanvraagbodyRequest body

De hoofdtekst van het bericht moet zich in JSON.The body of the message must be in JSON. Er moet een of meer records met de eigenschap naam / waarde-paren opnemen in deze indeling:It must include one or more records with the property name and value pairs in this format:

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

U kunt meerdere records samen in één aanvraag batch met behulp van de volgende indeling hebben.You can batch multiple records together in a single request by using the following format. Alle records moet hetzelfde type zijn.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"
    }
]

Recordtype en eigenschappenRecord type and properties

Wanneer u gegevens via de API van Azure Monitor HTTP Data Collector verzendt definieert u een aangepaste recordtype.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. U kunt gegevens op dit moment kan niet schrijven naar bestaande typen bronrecords vermeld die zijn gemaakt door andere gegevenstypen en -oplossingen.Currently, you can't write data to existing record types that were created by other data types and solutions. Azure Monitor leest de binnenkomende gegevens en maakt vervolgens eigenschappen die overeenkomen met de gegevenstypen van de waarden die u invoert.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Elke aanvraag aan de Data Collector-API moet bevatten een Logboektype -header met de naam van het recordtype.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Het achtervoegsel _CL wordt automatisch toegevoegd aan de naam die u invoert voor deze onderscheidt van andere typen logboeken als een aangepast logboek.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Bijvoorbeeld, als u de naam invoeren MyNewRecordType, maakt u een record met het type Azure Monitor MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. Dit zorgt ervoor dat er geen conflicten tussen typenamen die door de gebruiker heeft gemaakt en die in de huidige of toekomstige Microsoft-oplossingen hebt verzonden zijn.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Voor het identificeren van het gegevenstype van een eigenschap, voegt Azure Monitor het achtervoegsel aan de naam van de eigenschap.To identify a property's data type, Azure Monitor adds a suffix to the property name. Als een eigenschap een null-waarde bevat, wordt de eigenschap is niet opgenomen in die record.If a property contains a null value, the property is not included in that record. Deze tabel bevat de eigenschap gegevenstype en de bijbehorende achtervoegsel:This table lists the property data type and corresponding suffix:

Eigenschap gegevenstypeProperty data type SuffixSuffix
StringString _s_s
BooleanBoolean _b_b
DoubleDouble _d_d
Datum/tijdDate/time _t_t
GUIDGUID _g_g

Het gegevenstype dat Azure Monitor voor elke eigenschap gebruikt is afhankelijk van of het recordtype voor de nieuwe record al bestaat.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Als het recordtype niet bestaat nog, wordt een nieuw wachtwoord met behulp van het type JSON Deductie om te bepalen van het gegevenstype voor elke eigenschap voor de nieuwe record gemaakt in Azure Monitor.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.
  • Als het recordtype bestaat, wordt Azure Monitor probeert te maken van een nieuwe record op basis van bestaande eigenschappen.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Als de gegevens voor een eigenschap in de nieuwe record komt niet overeen met en kan niet worden geconverteerd naar het type van een bestaande, of als de record een eigenschap die niet bestaat bevat, maakt u een nieuwe eigenschap met het achtervoegsel van de relevante Azure Monitor.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.

Deze vermelding inzending zou bijvoorbeeld een record maken met drie eigenschappen number_d, boolean_b, en string_s:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Voorbeeldrecord 1

Als u deze volgende vermelding, klik vervolgens met alle waarden die zijn opgemaakt als tekenreeksen hebt ingediend, worden de eigenschappen zou niet wijzigen.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Deze waarden kunnen worden geconverteerd naar bestaande gegevenstypen:These values can be converted to existing data types:

Voorbeeldrecord 2

Maar als u deze volgende verzending vervolgens gemaakt, maakt Azure Monitor de eigenschappen van nieuwe boolean_d en string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Deze waarden kunnen niet worden geconverteerd:These values can't be converted:

Voorbeeldrecord 3

Als u de volgende vermelding, klikt u vervolgens verzonden voordat het recordtype is gemaakt, Azure Monitor een record wilt maken met drie eigenschappen gunstig, boolean_s, en 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 deze post is elk van de oorspronkelijke waarden opgemaakt als een tekenreeks:In this entry, each of the initial values is formatted as a string:

Voorbeeldrecord 4

Gereserveerde eigenschappenReserved properties

De volgende eigenschappen zijn gereserveerd en mag niet worden gebruikt in een aangepaste recordtype.The following properties are reserved and should not be used in a custom record type. U ontvangt een foutmelding als de nettolading een van de namen van deze eigenschappen bevat.You will receive an error if your payload includes any of these property names.

  • tenanttenant

GegevenslimietenData limits

Er zijn enkele beperkingen om de gegevens in de gegevensverzameling van Azure Monitor API geplaatst.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Maximaal 30 MB per post naar Azure Monitor Data Collector-API.Maximum of 30 MB per post to Azure Monitor Data Collector API. Dit is een maximale grootte voor een enkel bericht.This is a size limit for a single post. Als de gegevens van één die boeken groter is dan 30 MB, moet u de gegevens tot een kleinere grootte segmenten splitsen en ze gelijktijdig te verzenden.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.
  • Maximum van 32 KB-limiet voor veldwaarden.Maximum of 32 KB limit for field values. Als de veldwaarde groter dan 32 KB is, wordt de gegevens worden afgekapt.If the field value is greater than 32 KB, the data will be truncated.
  • Aanbevolen maximumaantal velden voor een bepaald type is 50.Recommended maximum number of fields for a given type is 50. Dit is een limiet van bruikbaarheid en zoeken ervaring perspectief.This is a practical limit from a usability and search experience perspective.
  • Een tabel in een werkruimte voor Log Analytics biedt alleen ondersteuning voor maximaal 500 kolommen (aangeduid als een veld in dit artikel).A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Het maximum aantal tekens in voor de naam van de kolom is 500.The maximum number of characters for the column name is 500.

RetourcodesReturn codes

De HTTP-statuscode 200 betekent dat de aanvraag is ontvangen voor verwerking.The HTTP status code 200 means that the request has been received for processing. Hiermee wordt aangegeven dat de bewerking is voltooid.This indicates that the operation completed successfully.

Deze tabel bevat de volledige reeks statuscodes die de service kan worden geretourneerd:This table lists the complete set of status codes that the service might return:

CodeCode StatusStatus FoutcodeError code DescriptionDescription
200200 OKOK De aanvraag is geaccepteerd.The request was successfully accepted.
400400 Ongeldig verzoekBad request InactiveCustomerInactiveCustomer De werkruimte is gesloten.The workspace has been closed.
400400 Ongeldig verzoekBad request InvalidApiVersionInvalidApiVersion De API-versie die u hebt opgegeven is niet herkend door de service.The API version that you specified was not recognized by the service.
400400 Ongeldig verzoekBad request InvalidCustomerIdInvalidCustomerId De opgegeven werkruimte-ID is ongeldig.The workspace ID specified is invalid.
400400 Ongeldig verzoekBad request InvalidDataFormatInvalidDataFormat Ongeldige JSON is ingediend.Invalid JSON was submitted. De antwoordtekst kan bevatten meer informatie over de fout op te lossen.The response body might contain more information about how to resolve the error.
400400 Ongeldig verzoekBad request InvalidLogTypeInvalidLogType Het logboektype opgegeven ingesloten speciale tekens of cijfers.The log type specified contained special characters or numerics.
400400 Ongeldig verzoekBad request MissingApiVersionMissingApiVersion De API-versie is niet opgegeven.The API version wasn’t specified.
400400 Ongeldig verzoekBad request MissingContentTypeMissingContentType Het inhoudstype is niet opgegeven.The content type wasn’t specified.
400400 Ongeldig verzoekBad request MissingLogTypeMissingLogType De vereiste waarde Logboektype is niet opgegeven.The required value log type wasn’t specified.
400400 Ongeldig verzoekBad request UnsupportedContentTypeUnsupportedContentType Het inhoudstype is niet ingesteld op application/json.The content type was not set to application/json.
403403 VerbodenForbidden InvalidAuthorizationInvalidAuthorization De service kan niet verifiëren van de aanvraag.The service failed to authenticate the request. Controleer of de sleutel van de werkruimte-ID en verbinding geldig zijn.Verify that the workspace ID and connection key are valid.
404404 Niet gevondenNot Found De opgegeven URL is onjuist, of de aanvraag is te groot.Either the URL provided is incorrect, or the request is too large.
429429 Te veel aanvragenToo Many Requests De service ondervindt een groot aantal gegevens uit uw account.The service is experiencing a high volume of data from your account. Probeer de aanvraag later opnieuw.Please retry the request later.
500500 Interne serverfoutInternal Server Error UnspecifiedErrorUnspecifiedError De service is een interne fout opgetreden.The service encountered an internal error. Probeer de aanvraag.Please retry the request.
503503 Service is niet beschikbaarService Unavailable ServiceUnavailableServiceUnavailable De service is momenteel niet beschikbaar is om aanvragen te ontvangen.The service currently is unavailable to receive requests. Probeer uw aanvraag.Please retry your request.

QuerygegevensQuery data

Query uitvoeren op gegevens verzonden door de Azure Monitor HTTP Data Collector-API, zoeken naar records met Type die gelijk is aan de LogType waarde die u hebt opgegeven, met het achtervoegsel _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. Als u gebruikt bijvoorbeeld MyCustomLog, zou u alle records geretourneerd MyCustomLog_CL.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Van voorbeeldaanvragenSample requests

In de volgende secties vindt u voorbeelden van hoe u gegevens naar de API van Azure Monitor HTTP Data Collector indienen met behulp van verschillende programmeertalen.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.

Voer deze stappen om de variabelen voor de autorisatie-header voor elk voorbeeld:For each sample, do these steps to set the variables for the authorization header:

  1. Ga naar uw Log Analytics-werkruimte in de Azure-portal.In the Azure portal, locate your Log Analytics workspace.
  2. Selecteer geavanceerde instellingen en vervolgens verbonden bronnen.Select Advanced Settings and then Connected Sources.
  3. Aan de rechterkant van werkruimte-ID, selecteer het kopieerpictogram en plak de-ID als de waarde van de klant-ID variabele.To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. Aan de rechterkant van primaire sleutel, selecteer het kopieerpictogram en plak de-ID als de waarde van de gedeelde sleutel variabele.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

U kunt ook de variabelen voor de Logboektype en JSON-gegevens wijzigen.Alternatively, you can change the variables for the log type and JSON data.

Voorbeeld van PowerShellPowerShell 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": "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 `
        -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#-voorbeeldC# 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);
            }
        }
    }
}

Voorbeeld van Python 2Python 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)

Alternatieven en overwegingenAlternatives and considerations

De Collector-API moet beslaat van uw behoeften voor het verzamelen van vrije-gegevens in Azure-Logboeken, maar er zijn gevallen waarbij alternatief nodig zijn om het oplossen van enkele van de beperkingen van de API.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. Alle uw opties zijn als volgt de belangrijkste zaken die zijn opgenomen:All your options are as follows, major considerations included:

AlternatieveAlternative DescriptionDescription Het meest geschikt voorBest suited for
Aangepaste gebeurtenissen: Systeemeigen SDK op basis van opname in Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, doorgaans geïnstrumenteerd via een SDK in uw toepassing, biedt de mogelijkheid voor u om aangepaste gegevens door middel van aangepaste gebeurtenissen te verzenden.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Gegevens die is gegenereerd in uw toepassing, maar niet zijn doorgevoerd door SDK via een van de standaard-gegevenstypen (ie: aanvragen, afhankelijkheden, uitzonderingen, enzovoort).Data that is generated within your application, but not picked up by SDK through one of the default data types (ie: requests, dependencies, exceptions, etc).
  • Gegevens die vaak wordt gecorreleerd met de andere toepassingsgegevens in Application InsightsData that is most often correlated to other application data in Application Insights
Gegevensverzamelaar-API in Logboeken van Azure MonitorData Collector API in Azure Monitor Logs De Collector-API in Azure Monitor-Logboeken is een volledig mogelijkheden voor opname van gegevens.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Geen gegevens ingedeeld in een JSON-object kunnen hier worden verzonden.Any data formatted in a JSON object can be sent here. Als verzonden, wordt verwerkt en beschikbaar zijn in Logboeken om te worden gecorreleerd met andere gegevens in Logboeken of op basis van andere Application Insights gegevens.Once sent, it will be processed, and available in Logs to be correlated with other data in Logs or against other Application Insights data.

Het is redelijk eenvoudig de gegevens te uploaden als bestanden naar een Azure Blob-blob uit waar deze bestanden worden verwerkt en geüpload naar Log Analytics.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. Raadpleeg dit artikel voor een Voorbeeldimplementatie van dergelijke een pijplijn.Please see this article for a sample implementation of such a pipeline.
  • Gegevens die niet noodzakelijkerwijs worden gegenereerd in een toepassing die is geïnstrumenteerd in Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Voorbeelden zijn onder meer lookup-en feitentabellen, referentiegegevens, vooraf samengevoegde statistieken, enzovoort.Examples include lookup and fact tables, reference data, pre-aggregated statistics, etc.
  • Bedoeld voor gegevens die op basis van andere Azure Monitor-gegevens (bijvoorbeeld Application Insights, andere gegevenstypen Logboeken, Security Center, Azure-Monitor voor Containers/VM's, enzovoort) waarnaar wordt verwezen.Intended for data that will be cross-referenced against other Azure Monitor data (for example, Application Insights, other Logs data types, Security Center, Azure Monitor for Containers/VMs, etc).
Azure Data ExplorerAzure Data Explorer Azure Data Explorer (ADX) is het gegevensplatform dat wordt gebruikt door Application Insights Analytics en logboeken van Azure Monitor.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Nu biedt algemeen beschikbaar ('GA'), met behulp van het gegevensplatform in ruwe vorm u volledige flexibiliteit (maar waarvoor de overhead van het management) ten opzichte van het cluster (RBAC, Retentiepercentage, schema, enzovoort).Now Generally Availabile ("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, etc). ADX biedt veel opname opties inclusief CSV, TSV en JSON bestanden.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Gegevens die niet wordt worden gecorreleerd met andere gegevens in Application Insights of de logboeken.Data that will not be correlated to any other data under Application Insights or Logs.
  • Gegevens vereisen geavanceerde opname of vandaag nog niet beschikbaar in Logboeken van Azure Monitor-verwerkingsmogelijkheden.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Volgende stappenNext steps