Skicka loggdata till Azure Monitor med API: t för HTTP-datainsamling (offentlig för hands version)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

Den här artikeln visar hur du använder API: t för HTTP-datainsamling för att skicka logg data till Azure Monitor från en REST API-klient.This article shows you how to use the HTTP Data Collector API to send log data to Azure Monitor from a REST API client. Här beskrivs hur du formaterar data som samlats in av ditt skript eller program, inkluderar dem i en begäran och har den begäran som auktoriserats av 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. Exempel finns för PowerShell, C#och python.Examples are provided for PowerShell, C#, and Python.

Anteckning

Den här artikeln har nyligen uppdaterats för användning av term Azure Monitors loggar i stället för Log Analytics.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Loggdata lagras fortfarande i en Log Analytics arbets yta och samlas in och analyseras fortfarande av samma Log Analytics-tjänst.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. Vi uppdaterar terminologin för att bättre avspegla rollen för loggar i Azure Monitor.We are updating the terminology to better reflect the role of logs in Azure Monitor. Se Azure Monitor terminologis ändringar för mer information.See Azure Monitor terminology changes for details.

Anteckning

API: et för Azure Monitor HTTP-datacollector finns i offentlig för hands version.The Azure Monitor HTTP Data Collector API is in public preview.

KonceptConcepts

Du kan använda API: t för HTTP-datainsamling för att skicka loggdata till en Log Analytics arbets yta i Azure Monitor från alla klienter som kan anropa en REST API.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. Detta kan vara en Runbook i Azure Automation som samlar in hanterings data från Azure eller ett annat moln, eller så kan det vara ett annat hanterings system som använder Azure Monitor för att konsolidera och analysera loggdata.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.

Alla data i arbets ytan Log Analytics lagras som en post med en viss post typ.All data in the Log Analytics workspace is stored as a record with a particular record type. Du formaterar dina data så att de skickas till API: et för HTTP-datainsamling som flera poster i JSON.You format your data to send to the HTTP Data Collector API as multiple records in JSON. När du skickar data skapas en enskild post i lagrings platsen för varje post i nytto lasten för begäran.When you submit the data, an individual record is created in the repository for each record in the request payload.

Översikt över HTTP-datainsamling

Skapa en begäranCreate a request

Om du vill använda API: et för HTTP-datainsamling skapar du en POST-begäran som innehåller de data som ska skickas i 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). I följande tre tabeller visas de attribut som krävs för varje begäran.The next three tables list the attributes that are required for each request. Vi beskriver varje attribut mer detaljerat längre fram i artikeln.We describe each attribute in more detail later in the article.

Begärd URIRequest URI

AttributAttribute EgenskapProperty
MetodMethod EFTERPOST
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
Innehålls typContent type application/jsonapplication/json

Begär URI-parametrarRequest URI parameters

ParameterParameter BeskrivningDescription
KundCustomerID Den unika identifieraren för Log Analytics arbets ytan.The unique identifier for the Log Analytics workspace.
ResursResource API-resursens namn:/API/logs.The API resource name: /api/logs.
API-versionAPI Version Den version av API: et som ska användas med den här begäran.The version of the API to use with this request. För närvarande är det 2016-04-01.Currently, it's 2016-04-01.

BegärandehuvudenRequest headers

HuvudHeader BeskrivningDescription
AutentiseringAuthorization Signaturen för auktorisering.The authorization signature. Senare i artikeln kan du läsa om hur du skapar ett HMAC-SHA256-huvud.Later in the article, you can read about how to create an HMAC-SHA256 header.
Logg typLog-Type Ange post typen för de data som skickas.Specify the record type of the data that is being submitted. Får bara innehålla bokstäver, siffror och under streck () och får inte överstiga 100 tecken.Can only contain letters, numbers, and underscore (), and may not exceed 100 characters.
x-MS-datex-ms-date Datumet då begäran bearbetades i RFC 1123-format.The date that the request was processed, in RFC 1123 format.
x-MS-AzureResourceIdx-ms-AzureResourceId Resurs-ID för den Azure-resurs som data ska associeras med.Resource ID of the Azure resource the data should be associated with. Detta fyller i egenskapen _ResourceId och gör att data kan tas med i resurs kontext frågor.This populates the _ResourceId property and allows the data to be included in resource-context queries. Om det här fältet inte anges tas data inte med i resurs kontext frågor.If this field isn't specified, the data will not be included in resource-context queries.
tidsgenererat-fälttime-generated-field Namnet på ett fält i data som innehåller tidsstämpeln för dataobjektet.The name of a field in the data that contains the timestamp of the data item. Om du anger ett fält används dess innehåll för TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Om det här fältet inte anges är standardvärdet för TimeGenerated den tidpunkt då meddelandet matas in.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. Innehållet i meddelande fältet ska följa ISO 8601-formatet ÅÅÅÅ-MM-DDThh: mm: ssZ.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AutentiseringAuthorization

Alla förfrågningar till API: et för Azure Monitor HTTP-datainsamling måste innehålla ett Authorization-huvud.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Om du vill autentisera en begäran måste du signera begäran med antingen den primära eller sekundära nyckeln för arbets ytan som gör begäran.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. Sedan skickar du signaturen som en del av begäran.Then, pass that signature as part of the request.

Här är formatet för Authorization-huvudet:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID är den unika identifieraren för Log Analytics arbets ytan.WorkspaceID is the unique identifier for the Log Analytics workspace. Signaturen är en Hash-baserad Message Authentication Code (HMAC) som är konstruerad från begäran och sedan beräknas med hjälp av SHA256-algoritmen.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Sedan kodar du den med base64-kodning.Then, you encode it by using Base64 encoding.

Använd det här formatet för att koda signatur strängen SharedKey :Use this format to encode the SharedKey signature string:

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

Här är ett exempel på en signatur sträng: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

När du har signatur strängen kodar du den med hjälp av HMAC-SHA256-algoritmen på UTF-8-kodad sträng och kodar sedan resultatet som 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. Använd det här formatet:Use this format:

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

Exemplen i följande avsnitt innehåller exempel kod som hjälper dig att skapa ett Authorization-huvud.The samples in the next sections have sample code to help you create an authorization header.

BegärandetextRequest body

Meddelandets brödtext måste vara i JSON.The body of the message must be in JSON. Den måste innehålla en eller flera poster med egenskaps namn och värdepar i följande format.It must include one or more records with the property name and value pairs in the following format. Egenskaps namnet får bara innehålla bokstäver, siffror och under streck ().The property name can only contain letters, numbers, and underscore ().

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

Du kan gruppera flera poster tillsammans i en enskild begäran med hjälp av följande format.You can batch multiple records together in a single request by using the following format. Alla poster måste vara av samma post typ.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"
    }
]

Post typ och egenskaperRecord type and properties

Du definierar en anpassad posttyp när du skickar data via Azure Monitor API för HTTP-datainsamling.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. För närvarande kan du inte skriva data till befintliga post typer som har skapats av andra data typer och lösningar.Currently, you can't write data to existing record types that were created by other data types and solutions. Azure Monitor läser inkommande data och skapar sedan egenskaper som matchar data typerna för de värden som du anger.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Varje begäran till data insamlings-API: n måste innehålla ett logg typs huvud med namnet på post typen.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Suffixet _CL läggs automatiskt till det namn som du anger för att skilja det från andra logg typer som en anpassad logg.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Om du till exempel anger namnet MyNewRecordTypeskapar Azure Monitor en post med typen MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. Detta säkerställer att det inte finns några konflikter mellan användardefinierade typnamn och de som levererats i aktuella eller framtida Microsoft-lösningar.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Azure Monitor lägger till ett suffix till egenskaps namnet för att identifiera en egenskaps datatyp.To identify a property's data type, Azure Monitor adds a suffix to the property name. Om en egenskap innehåller ett null-värde ingår inte egenskapen i posten.If a property contains a null value, the property is not included in that record. Den här tabellen visar data typen för egenskapen och motsvarande suffix:This table lists the property data type and corresponding suffix:

Egenskaps data typProperty data type HuvudnamnssuffixSuffix
SträngString _s_s
BooleskBoolean _b_b
DubbelklickaDouble _d_d
Datum/tidDate/time _t_t
GUID (lagras som en sträng)GUID (stored as a string) _g_g

Vilken datatyp som Azure Monitor används för varje egenskap beror på om post typen för den nya posten redan finns.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Om post typen inte finns skapar Azure Monitor en ny med hjälp av JSON-typens härledning för att fastställa data typen för varje egenskap för den nya posten.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.
  • Om post typen finns Azure Monitor försöker skapa en ny post utifrån befintliga egenskaper.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Om data typen för en egenskap i den nya posten inte matchar och inte kan konverteras till den befintliga typen, eller om posten innehåller en egenskap som inte finns, skapar Azure Monitor en ny egenskap som har det relevanta suffixet.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.

Denna överförings post skapar till exempel en post med tre egenskaper, number_d, boolean_boch string_s:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Exempel post 1

Om du sedan skickat in nästa post med alla värden formaterade som strängar, ändras inte egenskaperna.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Dessa värden kan konverteras till befintliga data typer:These values can be converted to existing data types:

Exempel post 2

Men om du sedan gör nästa överföring skapar Azure Monitor de nya egenskaperna boolean_d och string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Dessa värden kan inte konverteras:These values can't be converted:

Exempel post 3

Om du sedan skickade följande post innan post typen skapades, skulle Azure Monitor skapa en post med tre egenskaper, antal_l, boolean_soch 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. I den här posten formateras var och en av de ursprungliga värdena som en sträng:In this entry, each of the initial values is formatted as a string:

Exempel post 4

Reserverade egenskaperReserved properties

Följande egenskaper är reserverade och ska inte användas i en anpassad posttyp.The following properties are reserved and should not be used in a custom record type. Du får ett fel meddelande om nytto lasten innehåller något av dessa egenskaps namn.You will receive an error if your payload includes any of these property names.

  • innehavtenant

DatabegränsningarData limits

Det finns vissa begränsningar kring de data som skickas till API: et för Azure Monitor data insamling.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Högst 30 MB per post till Azure Monitor API för data insamling.Maximum of 30 MB per post to Azure Monitor Data Collector API. Detta är en storleks gräns för ett enskilt inlägg.This is a size limit for a single post. Om data från ett enda inlägg som överstiger 30 MB, bör du dela upp data upp till mindre segment och skicka dem samtidigt.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.
  • Högst 32 KB-gräns för fält värden.Maximum of 32 KB limit for field values. Om fältvärdet är större än 32 KB kommer data att trunkeras.If the field value is greater than 32 KB, the data will be truncated.
  • Rekommenderat Max antal fält för en specifik typ är 50.Recommended maximum number of fields for a given type is 50. Detta är en praktisk gräns från en användbarhet och ett Sök upplevelse perspektiv.This is a practical limit from a usability and search experience perspective.
  • En tabell i en Log Analytics-arbetsyta stöder endast upp till 500 kolumner (kallas för ett fält i den här artikeln).A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Det maximala antalet tecken för kolumn namnet är 500.The maximum number of characters for the column name is 500.

Retur koderReturn codes

HTTP-statuskod 200 innebär att begäran har tagits emot för bearbetning.The HTTP status code 200 means that the request has been received for processing. Detta anger att åtgärden har slutförts.This indicates that the operation completed successfully.

Den här tabellen innehåller en fullständig uppsättning status koder som tjänsten kan returnera:This table lists the complete set of status codes that the service might return:

ProgrammeraCode StatusStatus FelkodError code BeskrivningDescription
200200 OKOK Begäran har godkänts.The request was successfully accepted.
400400 Felaktig begäranBad request InactiveCustomerInactiveCustomer Arbets ytan har stängts.The workspace has been closed.
400400 Felaktig begäranBad request InvalidApiVersionInvalidApiVersion Den angivna API-versionen kändes inte igen av tjänsten.The API version that you specified was not recognized by the service.
400400 Felaktig begäranBad request InvalidCustomerIdInvalidCustomerId Det angivna arbetsyte-ID: t är ogiltigt.The workspace ID specified is invalid.
400400 Felaktig begäranBad request InvalidDataFormatInvalidDataFormat Ogiltig JSON skickades.Invalid JSON was submitted. Svars texten kan innehålla mer information om hur du löser problemet.The response body might contain more information about how to resolve the error.
400400 Felaktig begäranBad request InvalidLogTypeInvalidLogType Logg typen som anges innehåller specialtecken eller siffror.The log type specified contained special characters or numerics.
400400 Felaktig begäranBad request MissingApiVersionMissingApiVersion Ingen API-version har angetts.The API version wasn’t specified.
400400 Felaktig begäranBad request MissingContentTypeMissingContentType Innehålls typen har inte angetts.The content type wasn’t specified.
400400 Felaktig begäranBad request MissingLogTypeMissingLogType Den obligatoriska värde logg typen har inte angetts.The required value log type wasn’t specified.
400400 Felaktig begäranBad request UnsupportedContentTypeUnsupportedContentType Innehålls typen har inte ställts in på Application/JSON.The content type was not set to application/json.
403403 FörbjudetForbidden InvalidAuthorizationInvalidAuthorization Tjänsten kunde inte autentisera begäran.The service failed to authenticate the request. Kontrol lera att arbetsyte-ID och anslutnings nyckel är giltiga.Verify that the workspace ID and connection key are valid.
404404 Hittades inteNot Found Antingen är den angivna URL: en felaktig eller så är begäran för stor.Either the URL provided is incorrect, or the request is too large.
429429 För många begär AndenToo Many Requests Tjänsten har en stor mängd data från ditt konto.The service is experiencing a high volume of data from your account. Försök att utföra begäran senare.Please retry the request later.
500500 Internt Server felInternal Server Error UnspecifiedErrorUnspecifiedError Ett internt fel inträffade i tjänsten.The service encountered an internal error. Försök att utföra begäran igen.Please retry the request.
503503 Tjänsten är inte tillgängligService Unavailable ServiceUnavailableServiceUnavailable Tjänsten är för närvarande inte tillgänglig för att ta emot begär Anden.The service currently is unavailable to receive requests. Försök att utföra begäran igen.Please retry your request.

Söka i dataQuery data

Om du vill fråga efter data som skickats av Azure Monitor API för HTTP-datainsamling kan du söka efter poster med en typ som är lika med det LogType -värde som du angav, sist i _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. Om du till exempel använde MyCustomLogreturnerar du alla poster med MyCustomLog_CL.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Exempel förfrågningarSample requests

I nästa avsnitt hittar du exempel på hur du skickar data till API: et för Azure Monitor HTTP-datainsamling genom att använda olika programmeringsspråk.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.

Utför följande steg för varje exempel för att ange variabler för Authorization-huvudet:For each sample, do these steps to set the variables for the authorization header:

  1. Leta upp Log Analytics arbets ytan i Azure Portal.In the Azure portal, locate your Log Analytics workspace.
  2. Välj Avancerade inställningar och sedan anslutna källor.Select Advanced Settings and then Connected Sources.
  3. Till höger om arbetsyte-IDväljer du kopierings ikonen och klistrar in ID: t som värdet för variabeln kund-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. Till höger om primär nyckelväljer du kopierings ikonen och klistrar sedan in ID: t som värdet för den delade nyckel variabeln.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

Du kan också ändra variablerna för logg typen och JSON-data.Alternatively, you can change the variables for the log type and JSON data.

PowerShell-exempelPowerShell 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 = "DateValue"


# 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#-exempelC# 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);
            }
        }
    }
}

Exempel på 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)

Alternativ och övervägandenAlternatives and considerations

Även om data insamlings-API: n ska innehålla de flesta av dina behov av att samla in information om fritt formulär till Azure-loggar, finns det instanser där ett alternativ kan krävas för att lösa vissa begränsningar i API: et.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. Alla alternativ är följande: viktiga överväganden ingår:All your options are as follows, major considerations included:

AndraAlternative BeskrivningDescription Passar bäst förBest suited for
Anpassade händelser: inbyggd SDK-baserad inmatning i Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, vanligt vis genom ett SDK i ditt program, ger dig möjlighet att skicka anpassade data via anpassade händelser.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Data som genereras i programmet, men som inte hämtats av SDK via någon av standard data typerna (begär Anden, beroenden, undantag och så vidare).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).
  • Data som ofta korreleras med andra program data i Application InsightsData that is most often correlated to other application data in Application Insights
API för data insamling i Azure Monitor loggarData Collector API in Azure Monitor Logs API för data insamling i Azure Monitor loggar är ett helt öppet sätt att mata in data.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Alla data som är formaterade i ett JSON-objekt kan skickas hit.Any data formatted in a JSON object can be sent here. När den har skickats bearbetas den och är tillgänglig i loggarna för att korreleras med andra data i loggarna eller mot andra Application Insights data.Once sent, it will be processed, and available in Logs to be correlated with other data in Logs or against other Application Insights data.

Det är ganska enkelt att överföra data som filer till en Azure blob-blob, från var de här filerna ska bearbetas och överföras till 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. I den här artikeln hittar du en exempel implementering av en sådan pipeline.Please see this article for a sample implementation of such a pipeline.
  • Data som inte nödvändigt vis genereras inom ett program som är instrumenterade i Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Exempel är lookup-och fakta tabeller, referens data, församlad statistik och så vidare.Examples include lookup and fact tables, reference data, pre-aggregated statistics, and so on.
  • Avsedd för data som ska refereras till i andra Azure Monitor data (Application Insights, andra loggar data typer, Security Center, Azure Monitor för behållare/VM: ar).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-DatautforskarenAzure Data Explorer Azure Datautforskaren (ADX) är den data plattform som ger Application Insights analys-och Azure Monitors loggar.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Nu är det allmänt tillgängligt ("GA"), med hjälp av data plattformen i sin RAW-form, och ger dig fullständig flexibilitet (men kräver hanterings kostnader) över klustret (RBAC, bevarande frekvens, schema och så vidare).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 tillhandahåller många inmatnings alternativ , till exempel CSV-, TSV-och JSON- filer.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Data som inte kommer att korreleras till andra data under Application Insights eller loggar.Data that will not be correlated to any other data under Application Insights or Logs.
  • Data som kräver avancerade inmatnings-eller bearbetnings funktioner som inte redan finns i Azure Monitor loggar.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Nästa stegNext steps