Logboek gegevens naar Azure Monitor verzenden met de HTTP-gegevens verzamelaar-API (open bare preview)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

In dit artikel leest u hoe u de HTTP data collector API kunt gebruiken om logboek gegevens te verzenden 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. Hierin wordt beschreven hoe u gegevens opmaakt die worden verzameld door uw script of toepassing, deze toevoegen aan een aanvraag en die aanvraag hebben toegestaan 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. Er zijn voor beelden van Power shell, C# en python.Examples are provided for PowerShell, C#, and Python.

Notitie

Dit artikel is onlangs bijgewerkt waarbij Log Analytics is vervangen door de term Azure Monitor-logboeken.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Logboekgegevens worden nog steeds opgeslagen in een Log Analytics-werkruimte, en worden nog steeds verzameld en geanalyseerd met 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. De terminologie wordt bijgewerkt om de rol van logboeken in Azure Monitor beter te weerspiegelen.We are updating the terminology to better reflect the role of logs in Azure Monitor. Zie Wijzigingen in Azure Monitor-terminologie voor meer informatie.See Azure Monitor terminology changes for details.

Notitie

De Azure Monitor HTTP-gegevens verzamelaar-API bevindt zich in de open bare preview.The Azure Monitor HTTP Data Collector API is in public preview.

ConceptenConcepts

U kunt de HTTP data collector API gebruiken om logboek gegevens te verzenden naar een Log Analytics-werk ruimte in Azure Monitor vanaf elke client die een REST API kan 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 kan een runbook zijn in Azure Automation waarmee beheer gegevens worden verzameld van Azure of een andere Cloud, of een ander beheer systeem is dat gebruikmaakt van Azure Monitor om logboek gegevens te consolideren en analyseren.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 werk ruimte Log Analytics worden opgeslagen als een record met een bepaald record type.All data in the Log Analytics workspace is stored as a record with a particular record type. U formatteert uw gegevens om deze te verzenden naar de HTTP data collector-API als meerdere records in JSON.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Wanneer u de gegevens verzendt, wordt er voor elke record in de aanvraag lading een afzonderlijke record in de opslag plaats gemaakt.When you submit the data, an individual record is created in the repository for each record in the request payload.

Overzicht van HTTP-gegevens verzamelaar

Een aanvraag makenCreate a request

Als u de HTTP data collector API wilt gebruiken, maakt u een POST-aanvraag die de gegevens bevat die moeten worden verzonden in de 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 geven een lijst van de kenmerken die zijn vereist voor elke aanvraag.The next three tables list the attributes that are required for each request. Verderop in dit artikel wordt elk kenmerk uitvoeriger 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
InhoudstypeContent type application/jsonapplication/json

URI-para meters aanvragenRequest URI parameters

ParameterParameter BeschrijvingDescription
CustomerIDCustomerID De unieke id voor de Log Analytics-werk ruimte.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 die moet worden gebruikt voor deze aanvraag.The version of the API to use with this request. Momenteel is dit 2016-04-01.Currently, it's 2016-04-01.

AanvraagheadersRequest headers

HeaderHeader BeschrijvingDescription
AutorisatieAuthorization De autorisatie handtekening.The authorization signature. Verderop in dit artikel vindt u meer informatie over het maken van een HMAC-SHA256-header.Later in the article, you can read about how to create an HMAC-SHA256 header.
Logboek-typeLog-Type Geef het record type op van de gegevens die worden verzonden.Specify the record type of the data that is being submitted. Mag alleen letters, cijfers en onderstrepings tekens () bevatten en mag niet langer zijn dan 100.Can only contain letters, numbers, and underscore (), and may not exceed 100 characters.
x-MS-datex-ms-date De datum waarop de aanvraag is verwerkt, in 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 waaraan de gegevens moeten worden gekoppeld.Resource ID of the Azure resource the data should be associated with. Hiermee wordt de eigenschap _ResourceId gevuld en kunnen de gegevens worden opgenomen in resource-context query's.This populates the _ResourceId property and allows the data to be included in resource-context queries. Als dit veld niet wordt opgegeven, worden de gegevens niet opgenomen in resource-context query's.If this field isn't specified, the data will not be included in resource-context queries.
gegenereerde tijd-veldtime-generated-field De naam van een veld in de gegevens die de tijds tempel van het gegevens item bevat.The name of a field in the data that contains the timestamp of the data item. Als u een veld opgeeft, wordt de inhoud ervan gebruikt voor TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Als dit veld niet is opgegeven, is de standaard waarde voor TimeGenerated het tijdstip waarop 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 veld bericht moet de ISO 8601-notatie JJJJ-MM-DDTuu: mm: ssZ hebben.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AutorisatieAuthorization

Elke aanvraag voor de Azure Monitor HTTP-gegevens verzamelaar-API moet een autorisatie-header bevatten.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Als u een aanvraag wilt verifiëren, moet u de aanvraag ondertekenen met de primaire of secundaire sleutel voor de werk ruimte die de aanvraag maakt.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. Geef vervolgens die hand tekening door als onderdeel van de aanvraag.Then, pass that signature as part of the request.

Dit is de indeling voor de autorisatie-header:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID is de unieke id voor de log Analytics-werk ruimte.WorkspaceID is the unique identifier for the Log Analytics workspace. Hand tekening is een op hash gebaseerde Message Authentication Code (HMAC) die is opgebouwd op basis van de aanvraag en vervolgens wordt berekend met behulp van de sha256-algoritme.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Vervolgens versleutelt u het met base64-code ring.Then, you encode it by using Base64 encoding.

Gebruik deze indeling om de teken reeks voor de SharedKey -hand tekening te coderen: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 voor beeld van een teken reeks voor hand tekeningen: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 teken reeks voor hand tekeningen hebt, versleutelt u deze met behulp van het HMAC-SHA256-algoritme voor de teken reeks met UTF-8-code ring en versleutelt u het resultaat als base64.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 voor beelden in de volgende secties bevatten voorbeeld code om u te helpen bij 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 hoofd tekst van het bericht moet JSON zijn.The body of the message must be in JSON. Het moet een of meer records bevatten met de eigenschaps naam en waardeparen in de volgende notatie.It must include one or more records with the property name and value pairs in the following format. De naam van de eigenschap mag alleen letters, cijfers en onderstrepings tekens () bevatten.The property name can only contain letters, numbers, and underscore ().

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

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

Record type en eigenschappenRecord type and properties

U definieert een aangepast record type wanneer u gegevens verzendt via de Azure Monitor HTTP-gegevens verzamelaar-API.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. Op dit moment kunt u geen gegevens schrijven naar bestaande record typen die zijn gemaakt door andere gegevens typen 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 inkomende gegevens en maakt vervolgens eigenschappen die overeenkomen met de gegevens typen 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 voor de Data Collector-API moet een header van het logboek type bevatten met de naam van het record type.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 om deze te onderscheiden van andere logboek typen als aangepast logboek.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Als u bijvoorbeeld de naam MyNewRecordTypeopgeeft, maakt Azure monitor een record met het type 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 zijn tussen door de gebruiker gemaakte type namen en die worden geleverd in huidige of toekomstige micro soft-oplossingen.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Als u het gegevens type van een eigenschap wilt identificeren, voegt Azure Monitor een achtervoegsel toe 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 niet in die record opgenomen.If a property contains a null value, the property is not included in that record. Deze tabel bevat het gegevens type van de eigenschap en het bijbehorende achtervoegsel:This table lists the property data type and corresponding suffix:

Eigenschaps gegevens typeProperty data type AchtervoegselSuffix
TekenreeksString _s_s
Boolean-waardeBoolean _b_b
DubbelDouble _d_d
Datum/tijdDate/time _t_t
GUID (opgeslagen als een teken reeks)GUID (stored as a string) _g_g

Notitie

Teken reeks waarden die worden weer gegeven als GUID'S, krijgen het _g achtervoegsel en zijn opgemaakt als een GUID, zelfs als de inkomende waarde geen streepjes bevat.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. Bijvoorbeeld: zowel "8145d822-13a7-44ad-859c-36f31a84f6dd" als "8145d82213a744ad859c36f31a84f6dd" worden opgeslagen als "8145d822-13a7-44ad-859c-36f31a84f6dd".For example, both "8145d822-13a7-44ad-859c-36f31a84f6dd" and "8145d82213a744ad859c36f31a84f6dd" will be stored as "8145d822-13a7-44ad-859c-36f31a84f6dd". De enige verschillen tussen deze en een andere teken reeks zijn de _g in de naam en het invoegen van streepjes als deze niet zijn opgegeven in de invoer.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.

Het gegevens type dat Azure Monitor gebruikt voor elke eigenschap is afhankelijk van het feit of het record type 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 record type niet bestaat, wordt door Azure Monitor een nieuwe gemaakt met behulp van het JSON-type deinterferentie om het gegevens type voor elke eigenschap voor de nieuwe record te bepalen.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 record type bestaat, probeert Azure Monitor een nieuwe record te maken op basis van bestaande eigenschappen.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Als het gegevens type voor een eigenschap in de nieuwe record niet overeenkomt met en niet kan worden geconverteerd naar het bestaande type, of als de record een eigenschap bevat die niet bestaat, maakt Azure Monitor een nieuwe eigenschap met het relevante achtervoegsel.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.

Met deze verzend vermelding maakt u bijvoorbeeld een record met drie eigenschappen, number_d, boolean_ben string_s:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Voorbeeld record 1

Als u deze volgende vermelding vervolgens hebt verzonden met alle waarden die zijn opgemaakt als teken reeksen, worden de eigenschappen niet gewijzigd.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 gegevens typen:These values can be converted to existing data types:

Voorbeeld record 2

Maar als u deze volgende verzen ding hebt gemaakt, Azure Monitor de nieuwe eigenschappen boolean_d en string_dmaken.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:

Voorbeeld record 3

Als u de volgende vermelding vervolgens hebt verzonden voordat het record type werd gemaakt, maakt Azure Monitor een record met drie eigenschappen, number_s, boolean_sen 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 vermelding wordt elk van de oorspronkelijke waarden opgemaakt als een teken reeks:In this entry, each of the initial values is formatted as a string:

Voorbeeld record 4

Gereserveerde eigenschappenReserved properties

De volgende eigenschappen zijn gereserveerd en mogen niet worden gebruikt in een aangepast record type.The following properties are reserved and should not be used in a custom record type. U krijgt een fout melding als uw payload een van deze eigenschaps namen bevat.You will receive an error if your payload includes any of these property names.

  • tenanttenant

GegevenslimietenData limits

Er zijn enkele beperkingen rond de gegevens die worden gepost naar de Azure Monitor Data Collection-API.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Maxi maal 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 één bericht.This is a size limit for a single post. Als de gegevens van één post die meer dan 30 MB overschrijden, moet u de gegevens opsplitsen naar kleinere segmenten en deze gelijktijdig 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.
  • Maxi maal 32 KB-limiet voor veld waarden.Maximum of 32 KB limit for field values. Als de veld waarde groter is dan 32 KB, worden de gegevens afgekapt.If the field value is greater than 32 KB, the data will be truncated.
  • Het aanbevolen maximum aantal velden voor een bepaald type is 50.Recommended maximum number of fields for a given type is 50. Dit is een praktische beperking van een oogpunt van bruikbaarheid en zoek ervaring.This is a practical limit from a usability and search experience perspective.
  • Een tabel in een Log Analytics-werk ruimte ondersteunt Maxi maal 500 kolommen (ook wel een veld genoemd 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 voor de naam van de kolom is 500.The maximum number of characters for the column name is 500.

Retour codesReturn codes

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

Deze tabel bevat de volledige set met status codes die de service kan retour neren:This table lists the complete set of status codes that the service might return:

CodeCode StatusStatus FoutcodeError code BeschrijvingDescription
200200 OKOK De aanvraag is geaccepteerd.The request was successfully accepted.
400400 Ongeldige aanvraagBad request InactiveCustomerInactiveCustomer De werk ruimte is gesloten.The workspace has been closed.
400400 Ongeldige aanvraagBad request InvalidApiVersionInvalidApiVersion De API-versie die u hebt opgegeven, wordt niet herkend door de service.The API version that you specified was not recognized by the service.
400400 Ongeldige aanvraagBad request InvalidCustomerIdInvalidCustomerId De opgegeven werk ruimte-ID is ongeldig.The workspace ID specified is invalid.
400400 Ongeldige aanvraagBad request InvalidDataFormatInvalidDataFormat Ongeldige JSON verzonden.Invalid JSON was submitted. De antwoord tekst bevat mogelijk meer informatie over het oplossen van de fout.The response body might contain more information about how to resolve the error.
400400 Ongeldige aanvraagBad request InvalidLogTypeInvalidLogType Het opgegeven logboek type bevat speciale tekens of cijfers.The log type specified contained special characters or numerics.
400400 Ongeldige aanvraagBad request MissingApiVersionMissingApiVersion De API-versie is niet opgegeven.The API version wasn’t specified.
400400 Ongeldige aanvraagBad request MissingContentTypeMissingContentType Het inhouds type is niet opgegeven.The content type wasn’t specified.
400400 Ongeldige aanvraagBad request MissingLogTypeMissingLogType Het vereiste logboek type voor de waarde is niet opgegeven.The required value log type wasn’t specified.
400400 Ongeldige aanvraagBad request UnsupportedContentTypeUnsupportedContentType Het inhouds type is niet ingesteld op Application/JSON.The content type was not set to application/json.
403403 VerbodenForbidden InvalidAuthorizationInvalidAuthorization De service kan de aanvraag niet verifiëren.The service failed to authenticate the request. Controleer of de werk ruimte-ID en de verbindings sleutel geldig zijn.Verify that the workspace ID and connection key are valid.
404404 Niet gevondenNot Found De gegeven 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 van uw account.The service is experiencing a high volume of data from your account. Voer de aanvraag later opnieuw uit.Please retry the request later.
500500 Interne server foutInternal Server Error UnspecifiedErrorUnspecifiedError Er is een interne fout opgetreden in de service.The service encountered an internal error. Voer de aanvraag opnieuw uit.Please retry the request.
503503 Service niet beschikbaarService Unavailable ServiceUnavailableServiceUnavailable De service is momenteel niet beschikbaar voor het ontvangen van aanvragen.The service currently is unavailable to receive requests. Probeer de aanvraag opnieuw uit te voeren.Please retry your request.

QuerygegevensQuery data

Als u query's wilt uitvoeren op gegevens die zijn verzonden door de Azure Monitor HTTP-gegevens verzamelaar-API, zoekt u naar records met een type dat gelijk is aan de LogType -waarde die u hebt opgegeven, toegevoegd met _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 bijvoorbeeld MyCustomLoghebt gebruikt, geeft u alle records met op MyCustomLog_CL .For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Voorbeeld aanvragenSample requests

In de volgende secties vindt u voor beelden van het verzenden van gegevens naar de Azure Monitor HTTP-gegevens verzamelaar-API met behulp van verschillende programmeer talen.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 voor elk voor beeld de volgende stappen uit om de variabelen in te stellen voor de autorisatie-header:For each sample, do these steps to set the variables for the authorization header:

  1. Zoek in de Azure Portal de Log Analytics-werk ruimte.In the Azure portal, locate your Log Analytics workspace.
  2. Selecteer agents beheren.Select Agents management.
  3. Selecteer het Kopieer pictogram rechts van werk ruimte-iden plak de id als de waarde van de variabele voor de klant-id .To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. Rechts van primaire sleutelselecteert u het Kopieer pictogram en plakt u 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 het logboek type 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": "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#-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);
            }
        }
    }
}

Python 2-voor beeldPython 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-voor beeldPython 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)

Alternatieven en overwegingenAlternatives and considerations

Terwijl de Data Collector-API het meren deel van uw behoeften voor het verzamelen van vrije-vorm gegevens in azure-logboeken moet omvatten, zijn er exemplaren die mogelijk vereist zijn om bepaalde beperkingen van de API te overwinnen.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. U kunt kiezen uit de volgende belang rijke overwegingen:All your options are as follows, major considerations included:

VervangenAlternative BeschrijvingDescription Geschikt voorBest suited for
Aangepaste gebeurtenissen: systeem eigen op SDK gebaseerde opname in Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, meestal door middel van een SDK binnen uw toepassing, biedt u de mogelijkheid om aangepaste gegevens via 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 in uw toepassing worden gegenereerd, maar niet door de SDK worden opgehaald via een van de standaard gegevens typen (aanvragen, afhankelijkheden, uitzonde ringen, enzovoort).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).
  • Gegevens die het meest worden gecorreleerd aan andere toepassings gegevens in Application InsightsData that is most often correlated to other application data in Application Insights
Data Collector-API in Azure Monitor-logboekenData Collector API in Azure Monitor Logs De Data Collector-API in Azure Monitor Logboeken is een volledig open manier om gegevens op te nemen.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Gegevens die in een JSON-object zijn ingedeeld, kunnen hier worden verzonden.Any data formatted in a JSON object can be sent here. Zodra de gegevens zijn verzonden, worden deze verwerkt en in logboeken weer gegeven om te worden gecorreleerd met andere vermeldingen in Logboeken of met 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 tamelijk eenvoudig om de gegevens als bestanden naar een Azure Blob-Blob te uploaden, vanaf 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 voor beeld van de implementatie van een dergelijke pijp lijn.Please see this article for a sample implementation of such a pipeline.
  • Gegevens die niet noodzakelijkerwijs worden gegenereerd binnen een toepassings instrument in Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Voor beelden zijn onder andere lookup-en feiten tabellen, referentie gegevens, vooraf geaggregeerde statistieken, enzovoort.Examples include lookup and fact tables, reference data, pre-aggregated statistics, and so on.
  • Bedoeld voor gegevens waarnaar wordt verwezen met andere Azure Monitor gegevens (Application Insights, andere gegevens typen van Logboeken, Security Center, Azure Monitor voor containers/Vm's, enzovoort).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) is het gegevens platform dat Application Insights Analytics-en Azure Monitor-logboeken aanstuurt.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Nu algemeen beschikbaar ("GA"), met behulp van het gegevens platform in het onbewerkte formulier, hebt u de flexibiliteit om te volt ooien (maar de overhead van het beheer vereisen) over het cluster (RBAC, bewaar frequentie, schema enzovoort).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 biedt veel opname opties , waaronder CSV-, TSV-en JSON- bestanden.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Gegevens die niet met andere gegevens onder Application Insights of Logboeken worden gecorreleerd.Data that will not be correlated to any other data under Application Insights or Logs.
  • Gegevens waarvoor geavanceerde opname-of verwerkings mogelijkheden zijn vereist, die momenteel niet beschikbaar zijn in Azure Monitor Logboeken.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Volgende stappenNext steps