Odeslat data protokolu pro monitorování Azure pomocí rozhraní API kolekce dat HTTP (public preview)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

V tomto článku se dozvíte, jak používat rozhraní API kolekce dat HTTP k odeslání dat protokolů do Azure monitoru z klienta REST API.This article shows you how to use the HTTP Data Collector API to send log data to Azure Monitor from a REST API client. Popisuje jak formátovat data shromážděná z vašich skriptů nebo aplikací, zahrnout do požadavku a jste tento požadavek na autorizaci pomocí Azure monitoru.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. Příklady jsou k dispozici pro prostředí PowerShell, C# a Python.Examples are provided for PowerShell, C#, and Python.

Poznámka

Tento článek byl nedávno aktualizován termín protokoly Azure monitoru nahrazujícím Log Analytics.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Data protokolu zůstanou uložena v pracovním prostoru Log Analytics stále shromažďují a analyzují ve stejné službě Log Analytics.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. Aktualizujeme terminologie lépe podle role protokolů ve službě Azure Monitor.We are updating the terminology to better reflect the role of logs in Azure Monitor. Zobrazit Azure Monitor terminologie změny podrobnosti.See Azure Monitor terminology changes for details.

Poznámka

Azure Monitor HTTP rozhraní API kolekce dat je ve verzi public preview.The Azure Monitor HTTP Data Collector API is in public preview.

KonceptyConcepts

Rozhraní API kolekce dat HTTP slouží k odesílání dat protokolu do pracovního prostoru Log Analytics ve službě Azure Monitor z libovolného klienta, která může volat rozhraní 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. To může být sady runbook ve službě Azure Automation, který shromažďuje správu dat z Azure nebo jiného cloudu nebo ji může být systém alternativní správy, který používá Azure monitoru ke konsolidaci a analyzuje data protokolů.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.

Všechna data v pracovním prostoru Log Analytics se ukládá jako záznam s konkrétní typ záznamu.All data in the Log Analytics workspace is stored as a record with a particular record type. Formátování dat k odeslání do rozhraní API kolekce dat HTTP jako více záznamů ve formátu JSON.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Při odesílání dat vrátí jednotlivý záznam se vytvoří v úložišti pro každý záznam v datové části požadavku.When you submit the data, an individual record is created in the repository for each record in the request payload.

Přehled kolekce dat HTTP

Vytvořit žádostCreate a request

Pokud chcete používat rozhraní API kolekce dat HTTP, můžete vytvořit požadavek POST, který obsahuje data k odeslání v zápisu JSON (JavaScript Object).To use the HTTP Data Collector API, you create a POST request that includes the data to send in JavaScript Object Notation (JSON). V následujících třech tabulkách jsou uvedeny atributy, které jsou požadovány pro každý požadavek.The next three tables list the attributes that are required for each request. Popisujeme podrobněji dále v tomto článku každý atribut.We describe each attribute in more detail later in the article.

Identifikátor URI žádostiRequest URI

AtributAttribute VlastnostProperty
MetodaMethod POSTPOST
Identifikátor 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
Typ obsahuContent type application/jsonapplication/json

Parametry identifikátoru URI žádostiRequest URI parameters

ParametrParameter PopisDescription
ID zákazníkaCustomerID Jedinečný identifikátor pro pracovní prostor Log Analytics.The unique identifier for the Log Analytics workspace.
ResourceResource Název prostředku rozhraní API: / api/logs.The API resource name: /api/logs.
Verze rozhraní APIAPI Version Verze rozhraní API pro použití s touto žádostí.The version of the API to use with this request. V současné době je 2016-04-01.Currently, it's 2016-04-01.

Hlavičky požadavkuRequest headers

ZáhlavíHeader PopisDescription
AutorizaceAuthorization Ověření podpisu.The authorization signature. Později v tomto článku najdete informace o tom, jak vytvořit hlavičku HMAC SHA256.Later in the article, you can read about how to create an HMAC-SHA256 header.
Log-TypeLog-Type Zadejte typ záznamu dat, která se právě odesílá.Specify the record type of the data that is being submitted. Omezení velikosti pro tento parametr je 100 znaků.The size limit for this parameter is 100 characters.
x-ms-datex-ms-date Datum zpracování žádosti, ve formátu RFC 1123.The date that the request was processed, in RFC 1123 format.
x-ms-AzureResourceIdx-ms-AzureResourceId ID prostředku Azure prostředku data měla být přidružená.Resource ID of the Azure resource the data should be associated with. Tím vyplníte _ResourceId vlastnost a umožňuje data, která mají být součástí zaměřené na prostředek dotazy.This populates the _ResourceId property and allows the data to be included in resource-centric queries. Pokud toto pole není zadán, data nebudou zahrnuty v dotazech zaměřené na prostředek.If this field isn't specified, the data will not be included in resource-centric queries.
čas vygenerované poletime-generated-field Název pole v datech, která obsahuje časové razítko datová položka.The name of a field in the data that contains the timestamp of the data item. Pokud určíte pole, pak jeho obsah se používají pro TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Pokud toto pole není zadán, výchozí hodnota pro TimeGenerated je čas, který se ingestuje zprávy.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. Obsah pole zprávy postupujte podle ISO 8601 formátu RRRR-MM-: ssZ.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AutorizaceAuthorization

Jakákoli žádost Azure Monitor HTTP rozhraní API kolekce dat musí obsahovat hlavičku autorizace.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Pro žádost o ověření, musíte podepsat žádost s primární nebo sekundární klíč pro pracovní prostor, který provádí požadavek.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. Předejte tento podpis jako součást požadavku.Then, pass that signature as part of the request.

Tady je formát pro autorizační hlavičky:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

ID pracovního prostoru je jedinečný identifikátor pro pracovní prostor Log Analytics.WorkspaceID is the unique identifier for the Log Analytics workspace. Podpis je Hash-based Message Authentication kód metoda HMAC () , který je vytvořen z požadavku a pak je vypočítán s použitím algoritmus SHA256.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Potom můžete zakódovat je pomocí kódování Base64.Then, you encode it by using Base64 encoding.

Použijte tento formát určený ke kódování SharedKey podpis řetězce:Use this format to encode the SharedKey signature string:

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

Tady je příklad podpis řetězce: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

Máte-li řetězec podpis, zakódovat je pomocí algoritmus HMAC SHA256 na řetězec kódování UTF-8 a potom kódování výsledek jako 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. Použijte tento formát:Use this format:

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

Ukázky v následujících částech obsahovat vzorový kód vám pomůže vytvořit autorizační hlavičky.The samples in the next sections have sample code to help you create an authorization header.

Text požadavkuRequest body

Text zprávy musí být ve formátu JSON.The body of the message must be in JSON. Musí obsahovat jeden nebo více záznamů pomocí dvojice název a hodnotu vlastnosti v tomto formátu: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"
    }
]

Pomocí následujícího formátu může hromadně společně v jedné žádosti více záznamů.You can batch multiple records together in a single request by using the following format. Stejný typ záznamu musí být všechny záznamy.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"
    }
]

Typ záznamu a vlastnostiRecord type and properties

Při odesílání dat prostřednictvím rozhraní Azure Monitor HTTP API kolekce dat, definovat vlastní typ záznamu.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. V současné době nelze zapisovat data do existující typy záznamů, které byly vytvořeny v jiných datových typů a řešení.Currently, you can't write data to existing record types that were created by other data types and solutions. Azure Monitor přečte příchozích dat a pak vytvoří vlastnosti, které odpovídají datové typy hodnot, které zadáte.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Musí zahrnovat každého požadavku rozhraní API kolekce dat typ protokolu záhlaví s názvem pro příslušný typ záznamu.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Přípona _CL se automaticky připojí k názvu zadáte, aby se odlišil od ostatních typů protokolu jako vlastní protokol.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Například, pokud zadáte název MyNewRecordType, Azure Monitor vytvoří záznam s typem MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. To pomáhá zajistit, že neexistují žádné konflikty mezi názvy typů vytvořené uživatelem a poskytuje současný nebo budoucí řešení Microsoftu.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Azure Monitor k identifikaci typ dat vlastnosti, přidá příponu název vlastnosti.To identify a property's data type, Azure Monitor adds a suffix to the property name. Pokud vlastnost obsahuje hodnotu null, vlastnost není zahrnutý v daném záznamu.If a property contains a null value, the property is not included in that record. Tato tabulka uvádí typ dat vlastnosti a odpovídající přípony:This table lists the property data type and corresponding suffix:

Typ dat vlastnostiProperty data type PříponaSuffix
StringString _s_s
BooleanBoolean _b_b
DoubleDouble _d_d
Datum a časDate/time _t_t
GUIDGUID _g_g

Datový typ, který používá Azure Monitor pro každou vlastnost závisí na tom, zda již existuje typ záznamu pro nový záznam.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Pokud typ záznamu neexistuje, vytvoří Azure Monitor novou zásadu pomocí odvození typu JSON určit typ dat pro každou vlastnost u nového záznamu.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.
  • Typ záznamu neexistuje, Azure Monitor se pokusí vytvořit nový záznam na základě existující vlastností.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Pokud datový typ pro vlastnost v novém záznamu zadané informace neodpovídají a nelze jej převést na stávající typ, nebo pokud tento záznam obsahuje vlastnost, která neexistuje, vytvoří Azure Monitor novou vlastnost, která má odpovídající příponu.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.

Například by tato položka odeslání vytvořit záznam s tři vlastnosti number_d, boolean_b, a string_s:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Ukázka záznamu 1

Pokud pak odešle tento další položce s všechny hodnoty ve formátu jako řetězce, nebude změna vlastnosti.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Tyto hodnoty lze převést na existující datové typy:These values can be converted to existing data types:

Ukázka záznamu 2

Ale pokud jste provedli poté toto další odeslání, Azure Monitor byste vytvořit nové vlastnosti boolean_d a string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Nelze převést tyto hodnoty:These values can't be converted:

Ukázka záznamu 3

Pokud potom odeslali následující položku předtím, než byl vytvořen typ záznamu, monitorování Azure by u tři vlastnosti, vytvořit záznam úspěch, boolean_s, a 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. Na tuto položku se všechny počáteční hodnoty naformátovaná jako řetězec:In this entry, each of the initial values is formatted as a string:

Ukázka záznamu 4

Rezervované vlastnostiReserved properties

Následující vlastnosti jsou vyhrazené a nesmí být použita v vlastní typ záznamu.The following properties are reserved and should not be used in a custom record type. Pokud vaše datová část obsahuje některé z těchto názvů vlastností, dojde k chybě.You will receive an error if your payload includes any of these property names.

  • tenanttenant

Omezení datData limits

Existují některá omezení kolem data vystavená pro rozhraní API pro shromažďování dat monitorování Azure.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Maximálně 30 MB na příspěvek k rozhraní API kolekce dat monitorování Azure.Maximum of 30 MB per post to Azure Monitor Data Collector API. Toto je omezení velikosti pro jeden příspěvek.This is a size limit for a single post. Pokud se data z jedné příspěvku, který překračuje 30 MB, měli rozdělit data do menších bloků velikosti dat a odešlete je současně.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.
  • Maximální limit 32 KB pro hodnoty pole.Maximum of 32 KB limit for field values. Pokud hodnota pole je větší než 32 KB, data se zkrátí.If the field value is greater than 32 KB, the data will be truncated.
  • Doporučený maximální počet polí pro daný typ je 50.Recommended maximum number of fields for a given type is 50. To je praktické omezení použitelnosti a perspektivy vyhledávací prostředí.This is a practical limit from a usability and search experience perspective.
  • Tabulky v pracovním prostoru Log Analytics podporuje jenom až 500 sloupce (označované jako pole v tomto článku).A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Maximální počet znaků pro název sloupce je 500.The maximum number of characters for the column name is 500.

Návratové kódyReturn codes

Stavový kód HTTP 200 znamená, že žádost byla přijata ke zpracování.The HTTP status code 200 means that the request has been received for processing. To znamená, že operace byla úspěšně dokončena.This indicates that the operation completed successfully.

Tato tabulka uvádí kompletní sadu stavové kódy, které může vrátit služby:This table lists the complete set of status codes that the service might return:

KódCode StatusStatus Kód chybyError code PopisDescription
200200 OKOK Požadavek byl úspěšně přijat.The request was successfully accepted.
400400 Nesprávná žádostBad request InactiveCustomerInactiveCustomer Pracovní prostor byl uzavřen.The workspace has been closed.
400400 Nesprávná žádostBad request InvalidApiVersionInvalidApiVersion Služba nebyla rozpoznána verze rozhraní API, který jste zadali.The API version that you specified was not recognized by the service.
400400 Nesprávná žádostBad request InvalidCustomerIdInvalidCustomerId Zadané ID pracovního prostoru je neplatný.The workspace ID specified is invalid.
400400 Nesprávná žádostBad request InvalidDataFormatInvalidDataFormat Neplatný identifikátor JSON se odeslal.Invalid JSON was submitted. Text odpovědi může obsahovat další informace o tom, jak tuto chybu napravíme.The response body might contain more information about how to resolve the error.
400400 Nesprávná žádostBad request InvalidLogTypeInvalidLogType Zadaný typ protokolu omezením speciální znaky nebo číslice.The log type specified contained special characters or numerics.
400400 Nesprávná žádostBad request MissingApiVersionMissingApiVersion Nebyla zadaná verze rozhraní API.The API version wasn’t specified.
400400 Nesprávná žádostBad request MissingContentTypeMissingContentType Nezadal se typ obsahu.The content type wasn’t specified.
400400 Nesprávná žádostBad request MissingLogTypeMissingLogType Typ protokolu požadovaná hodnota nebyla zadána.The required value log type wasn’t specified.
400400 Nesprávná žádostBad request UnsupportedContentTypeUnsupportedContentType Typ obsahu nebyl nastaven na application/json.The content type was not set to application/json.
403403 ZakázánoForbidden InvalidAuthorizationInvalidAuthorization Službu se nepovedlo ověřit žádost.The service failed to authenticate the request. Ověřte, že jsou platné ID a připojení klíče pracovního prostoru.Verify that the workspace ID and connection key are valid.
404404 Nebyl nalezenNot Found Zadaná adresa URL je nesprávná nebo požadavku je moc velká.Either the URL provided is incorrect, or the request is too large.
429429 Příliš mnoho žádostíToo Many Requests Služba dochází k velkému počtu data z vašeho účtu.The service is experiencing a high volume of data from your account. Zkuste prosím požadavek později.Please retry the request later.
500500 Vnitřní chyba serveruInternal Server Error UnspecifiedErrorUnspecifiedError Služby došlo k vnitřní chybě.The service encountered an internal error. Zkuste prosím požadavek.Please retry the request.
503503 Služba není k dispoziciService Unavailable ServiceUnavailableServiceUnavailable Služba je momentálně nedostupný a nepřijímá žádosti.The service currently is unavailable to receive requests. Zkuste to prosím znovu, vaši žádost.Please retry your request.

Dotazování datQuery data

Zadat dotaz na data odeslaná Azure monitoru HTTP rozhraní API kolekce dat, hledat záznamy s typ , který je roven LogType hodnotu, která jste zadali, s příponou _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. Například, pokud jste použili MyCustomLog, pak by vrátí všechny záznamy s MyCustomLog_CL.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Požadavky na ukázkySample requests

V následujících částech najdete ukázky toho, jak odesílat data Azure monitoru HTTP rozhraní API kolekce dat pomocí různých programovacích jazycích.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.

Pro každý vzorek proveďte tyto kroky k nastavení proměnných pro autorizační hlavičky:For each sample, do these steps to set the variables for the authorization header:

  1. Na webu Azure Portal vyhledejte pracovního prostoru Log Analytics.In the Azure portal, locate your Log Analytics workspace.
  2. Vyberte upřesňující nastavení a potom připojené zdroje.Select Advanced Settings and then Connected Sources.
  3. Napravo od ID pracovního prostoru, vyberte ikonu kopírování a vložte ID jako hodnotu ID zákazníka proměnné.To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. Napravo od primární klíč, vyberte ikonu kopírování a vložte ID jako hodnotu sdíleného klíče proměnné.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

Alternativně můžete změnit proměnné pro typ protokolu a dat JSON.Alternatively, you can change the variables for the log type and JSON data.

Ukázka PowerShelluPowerShell 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  

Ukázka v jazyce C#C# 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);
            }
        }
    }
}

Ukázka 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)

Možnosti a důležité informaceAlternatives and considerations

Rozhraní API kolekce dat by měl zahrnovat většinu, které potřebujete ke shromažďování dat volného tvaru do protokolů Azure, existuje instance, kde je alternativou může být nutné překonávat některá omezení rozhraní 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. Vaše možnosti jsou následujícím způsobem hlavní aspekty zahrnuté:All your options are as follows, major considerations included:

AlternativníAlternative PopisDescription VyhovujeBest suited for
Vlastní události: Nativní ingestování založené na sadě SDK ve službě Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, obvykle instrumentována prostřednictvím sady SDK v rámci vaší aplikace, nabízí možnost odesílat vlastní data prostřednictvím vlastních událostí.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Data, která je generována v rámci vaší aplikace, ale není vyzvednou SDK prostřednictvím jednoho z výchozí datové typy (ie: požadavky, závislosti, výjimky, atd.).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).
  • Data, která jsou nejčastěji korelována dalších dat aplikací ve službě Application InsightsData that is most often correlated to other application data in Application Insights
Rozhraní API kolekce dat v protokoly Azure monitoruData Collector API in Azure Monitor Logs Rozhraní API kolekce dat v protokolech Azure Monitor je zcela otevřený způsob, jak ingestovat data.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Zde nelze odesílat žádná data formátovaná v objektu JSON.Any data formatted in a JSON object can be sent here. Po odeslání se zpracuje a k dispozici v protokolech se korelují s další data v protokolech nebo proti jiné 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.

To je poměrně snadné nahrát data jako soubory do objektu blob Azure Blob z kde se tyto soubory zpracovat a nahrát do služby 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. Podrobnosti najdete na to článek ukázku implementace takových kanálu.Please see this article for a sample implementation of such a pipeline.
  • Data, která není nutně vygenerované v rámci aplikace instrumentovány v rámci Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Příklady vyhledávání a skutečnosti, tabulky, referenční data, předem agregovaných statistik, atd.Examples include lookup and fact tables, reference data, pre-aggregated statistics, etc.
  • Určená pro data, která bude křížovými odkazy na jiná data monitorování Azure (například Application Insights, jiné protokoly datové typy, Security Center, monitorování Azure pro kontejnery nebo virtuální počítače a tak dál).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).
Průzkumník dat AzureAzure Data Explorer Průzkumník Azure dat (ADX) je datová platforma, která je základem Application Insights Analytics a monitorování protokolů Azure.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Nyní obecně dostupná ("GA"), platformě data v nezpracované podobě poskytuje úplnou flexibilitu (ale vyžadující režii správy) v clusteru (RBAC, míra uchování, schéma, atd.).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 poskytuje mnoho možnosti ingestování včetně CSV, TSV a JSON soubory.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Data, která nebude korelují s jinými daty v rámci Application Insights nebo protokoly.Data that will not be correlated to any other data under Application Insights or Logs.
  • Data vyžadující advanced ingestování nebo zpracování funkce není ještě dnes k dispozici v protokolech monitorování Azure.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Další postupNext steps