Inviare dati di log a Monitoraggio di Azure con l'API di raccolta dati HTTP (anteprima pubblica)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

Questo articolo illustra come usare l'API di raccolta dati HTTP per inviare dati di log a Monitoraggio di Azure da un client dell'API REST.This article shows you how to use the HTTP Data Collector API to send log data to Azure Monitor from a REST API client. L'articolo descrive come formattare i dati raccolti dall'applicazione o dallo script, come includerli in una richiesta e come autorizzare tale richiesta in Monitoraggio di Azure.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. Vengono indicati esempi per PowerShell, C# e Python.Examples are provided for PowerShell, C#, and Python.

Nota

Questo articolo è stato aggiornato di recente in modo da usare il termine log di Monitoraggio di Azure anziché Log Analytics.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. I dati di log vengono comunque archiviati in un'area di lavoro Log Analytics e vengano ancora raccolti e analizzati dallo stesso servizio Log Analytics.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. Si sta procedendo a un aggiornamento della terminologia per riflettere meglio il ruolo dei log in Monitoraggio di Azure.We are updating the terminology to better reflect the role of logs in Azure Monitor. Per informazioni dettagliate, vedere Modifiche della terminologia di Monitoraggio di Azure.See Azure Monitor terminology changes for details.

Nota

L'API di raccolta dati HTTP di Monitoraggio di Azure è in anteprima pubblica.The Azure Monitor HTTP Data Collector API is in public preview.

ConcettiConcepts

È possibile usare l'API di raccolta dati HTTP per inviare dati di log a un'area di lavoro Log Analytics in Monitoraggio di Azure da qualsiasi client in grado di chiamare un'API REST.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. Può trattarsi di un runbook in Automazione di Azure che raccoglie dati di gestione da Azure o da un altro cloud oppure di un sistema di gestione alternativo che usa Monitoraggio di Azure per consolidare e analizzare i dati di log.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.

Tutti i dati nell'area di lavoro Log Analytics vengono archiviati come record con un tipo specifico.All data in the Log Analytics workspace is stored as a record with a particular record type. I dati da inviare all'API dell'agente di raccolta dati HTTP devono essere formattati come più record in JSON.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Quando si inviano i dati, nel repository viene creato un record singolo per ogni record presente nel payload della richiesta.When you submit the data, an individual record is created in the repository for each record in the request payload.

Panoramica dell'agente di raccolta dati HTTP

Creare una richiestaCreate a request

Per usare l'API dell'agente di raccolta dati HTTP, creare una richiesta POST che include i dati da inviare in formato JSON (JavaScript Object Notation).To use the HTTP Data Collector API, you create a POST request that includes the data to send in JavaScript Object Notation (JSON). Le tre tabelle successive indicano gli attributi necessari per ogni richiesta.The next three tables list the attributes that are required for each request. Ogni attributo viene descritto con maggiori dettagli più avanti nell'articolo.We describe each attribute in more detail later in the article.

URI della richiestaRequest URI

AttributoAttribute ProprietàProperty
MetodoMethod POSTPOST
URIURI https://<IdCliente>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01
Tipo di contenutoContent type application/jsonapplication/json

Parametri URI della richiestaRequest URI parameters

ParametroParameter DescriptionDescription
CustomerIDCustomerID Identificatore univoco per l'area di lavoro Log Analytics.The unique identifier for the Log Analytics workspace.
GruppiResource Nome della risorsa API: /api/logs.The API resource name: /api/logs.
Versione dell'APIAPI Version Versione dell'API da usare con questa richiesta.The version of the API to use with this request. La versione attuale è 2016-04-01.Currently, it's 2016-04-01.

Intestazioni della richiestaRequest headers

IntestazioneHeader DescriptionDescription
AuthorizationAuthorization Firma di autorizzazione.The authorization signature. Più avanti nell'articolo sono disponibili informazioni sulla creazione di un'intestazione HMAC-SHA256.Later in the article, you can read about how to create an HMAC-SHA256 header.
Log-TypeLog-Type Specificare il tipo di record dei dati inviati.Specify the record type of the data that is being submitted. Può contenere solo lettere, numeri e caratteri di sottolineatura () e non può superare i 100 caratteri.Can only contain letters, numbers, and underscore (), and may not exceed 100 characters.
x-ms-datex-ms-date Data di elaborazione della richiesta, in formato RFC 1123.The date that the request was processed, in RFC 1123 format.
x-ms-AzureResourceIdx-ms-AzureResourceId ID risorsa della risorsa di Azure a cui devono essere associati i dati.Resource ID of the Azure resource the data should be associated with. Questa operazione consente di popolare la proprietà _ResourceId e di includere i dati nelle query del contesto delle risorse .This populates the _ResourceId property and allows the data to be included in resource-context queries. Se questo campo non è specificato, i dati non verranno inclusi nelle query del contesto delle risorse.If this field isn't specified, the data will not be included in resource-context queries.
time-generated-fieldtime-generated-field Nome di un campo nei dati che contiene il timestamp dell'elemento di dati.The name of a field in the data that contains the timestamp of the data item. Se si specifica un campo, il relativo contenuto verrà usato per TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Se questo campo non è specificato, il valore predefinito di TimeGenerated sarà la data/ora di inserimento del messaggio.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. Il contenuto del campo del messaggio deve seguire il formato ISO 8601 AAAA-MM-GGThh:mm:ssZ.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AuthorizationAuthorization

Qualsiasi richiesta inviata all'API di raccolta dati HTTP di Monitoraggio di Azure deve includere l'intestazione dell'autorizzazione.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Per autenticare una richiesta è necessario firmarla con la chiave primaria o secondaria dell'area di lavoro che effettua la richiesta.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. Passare quindi la firma come parte della richiesta.Then, pass that signature as part of the request.

Il formato dell'intestazione dell'autorizzazione è il seguente:Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID è l'identificatore univoco per l'area di lavoro Log Analytics.WorkspaceID is the unique identifier for the Log Analytics workspace. Signature è un codice HMAC (Hash-based Message Authentication Code) che viene creato dalla richiesta e quindi calcolato con l'algoritmo SHA256.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Viene quindi codificato con la codifica Base64.Then, you encode it by using Base64 encoding.

Usare questo formato per codificare la stringa di firma 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";

Di seguito è riportato un esempio di stringa della firma: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

La stringa della firma deve essere codificata usando l'algoritmo HMAC-SHA256 sulla stringa con codifica UTF-8. Il risultato deve essere quindi codificato in 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. Usare il formato seguente:Use this format:

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

Gli esempi nelle sezioni successive indicano il codice di esempio per creare l'intestazione dell'autorizzazione.The samples in the next sections have sample code to help you create an authorization header.

Corpo della richiestaRequest body

Il corpo del messaggio deve essere in formato JSON.The body of the message must be in JSON. Deve includere uno o più record con le coppie nome e valore della proprietà nel formato seguente.It must include one or more records with the property name and value pairs in the following format. Il nome della proprietà può contenere solo lettere, numeri e caratteri di sottolineatura ().The property name can only contain letters, numbers, and underscore ().

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

È possibile creare batch di più record in una singola richiesta usando il formato seguente.You can batch multiple records together in a single request by using the following format. Tutti i record devono essere dello stesso tipo.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"
    }
]

Proprietà e tipo di recordRecord type and properties

Quando si inviano dati con l'API di raccolta dati HTTP di Monitoraggio di Azure si definisce un tipo di record personalizzato.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. È attualmente possibile scrivere dati nei tipi di record esistenti creati da altri tipi di dati e soluzioni.Currently, you can't write data to existing record types that were created by other data types and solutions. Monitoraggio di Azure legge i dati in ingresso e quindi crea le proprietà che corrispondono ai tipi di dati dei valori immessi.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Ogni richiesta all'API di raccolta dati deve includere un'intestazione Log-Type con il nome del tipo di record.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Il suffisso _CL viene aggiunto automaticamente al nome immesso per distinguerlo da altri tipi di log come log personalizzato.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Se ad esempio si immette il nome MyNewRecordType, Monitoraggio di Azure crea un record di tipo MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. È così possibile evitare conflitti tra i nomi dei tipi creati dall'utente e i nomi forniti nelle soluzioni Microsoft correnti o future.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Per identificare il tipo di dati di una proprietà, Monitoraggio di Azure aggiunge un suffisso al nome della proprietà.To identify a property's data type, Azure Monitor adds a suffix to the property name. Una proprietà con un valore null non viene inclusa in tale record.If a property contains a null value, the property is not included in that record. Questa tabella elenca il tipo di dati proprietà e il suffisso corrispondente:This table lists the property data type and corresponding suffix:

Tipo di dati proprietàProperty data type SuffissoSuffix
StringaString _s_s
booleanBoolean _b_b
DOUBLEDouble _d_d
Data/oraDate/time _t_t
GUID (archiviato come stringa)GUID (stored as a string) _g_g

Il tipo di dati usato da Monitoraggio di Azure per ogni proprietà dipende dall'eventuale esistenza di un tipo di record per il nuovo record.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Se il tipo di record non esiste, Monitoraggio di Azure ne crea uno nuovo usando l'inferenza del tipo JSON per determinare il tipo di dati per ogni proprietà del nuovo record.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.
  • Se il tipo di record esiste, Monitoraggio di Azure prova a creare un nuovo record in base alle proprietà esistenti.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Se il tipo di dati di una proprietà nel nuovo record non corrisponde e non può essere convertito nel tipo esistente, oppure se il record include una proprietà che non esiste, Monitoraggio di Azure crea una nuova proprietà con il suffisso pertinente.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.

Questa voce di invio creerà ad esempio un record con tre proprietà, number_d, boolean_b e string_s:For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Esempio di record 1

Inviando la voce seguente, con tutti i valori formattati come stringhe, le proprietà non cambieranno.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Questi valori possono essere convertiti in tipi di dati esistenti:These values can be converted to existing data types:

Esempio di record 2

Con l'invio seguente, tuttavia, Monitoraggio di Azure creerebbe le nuove proprietà boolean_d e string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Questi valori non possono essere convertiti:These values can't be converted:

Esempio di record 3

Inviando la voce seguente, prima della creazione del tipo di record Monitoraggio di Azure creerebbe un record con tre proprietà, number_s, boolean_s e 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 questa voce, ognuno dei valori iniziali viene formattato come stringa:In this entry, each of the initial values is formatted as a string:

Esempio di record 4

Proprietà riservateReserved properties

Le proprietà seguenti sono riservate e non devono essere utilizzate in un tipo di record personalizzato.The following properties are reserved and should not be used in a custom record type. Se il payload include uno di questi nomi di proprietà, verrà visualizzato un errore.You will receive an error if your payload includes any of these property names.

  • tenanttenant

Limiti dei datiData limits

Esistono alcune limitazioni riguardo ai dati pubblicati nell'API per la raccolta dei dati di Monitoraggio di Azure.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Limite di 30 MB per post nell'API per la raccolta dei dati di Monitoraggio di Azure.Maximum of 30 MB per post to Azure Monitor Data Collector API. Questo limite riguarda le dimensioni di ogni messaggio.This is a size limit for a single post. Se i dati di un singolo post superano i 30 MB, è necessario suddividerli in blocchi di dimensioni inferiori, che andranno inviati contemporaneamente.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.
  • Limite di 32 KB per i valori dei campi.Maximum of 32 KB limit for field values. Se il valore di un campo è superiore a 32 KB, i dati verranno troncati.If the field value is greater than 32 KB, the data will be truncated.
  • Il numero massimo di campi consigliato per un determinato tipo è 50.Recommended maximum number of fields for a given type is 50. Si tratta di un limite pratico dal punto di vista dell'usabilità e dell'esperienza di ricerca.This is a practical limit from a usability and search experience perspective.
  • Una tabella in un'area di lavoro Log Analytics supporta solo un massimo di 500 colonne, indicate in questo articolo come campi.A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Il numero massimo di caratteri per il nome della colonna è 500.The maximum number of characters for the column name is 500.

Codici restituitiReturn codes

Il codice di stato HTTP 200 indica che è stata ricevuta la richiesta per l'elaborazione.The HTTP status code 200 means that the request has been received for processing. L'operazione è stata completata correttamente.This indicates that the operation completed successfully.

Questa tabella elenca il set completo di codici di stato che il servizio può restituire:This table lists the complete set of status codes that the service might return:

CodiceCode StatusStatus Codice di erroreError code DescriptionDescription
200200 OKOK La richiesta è stata accettata.The request was successfully accepted.
400400 Richiesta non validaBad request InactiveCustomerInactiveCustomer L'area di lavoro è stata chiusa.The workspace has been closed.
400400 Richiesta non validaBad request InvalidApiVersionInvalidApiVersion La versione API specificata non è stata riconosciuta dal servizio.The API version that you specified was not recognized by the service.
400400 Richiesta non validaBad request InvalidCustomerIdInvalidCustomerId L'ID area di lavoro specificato non è valido.The workspace ID specified is invalid.
400400 Richiesta non validaBad request InvalidDataFormatInvalidDataFormat È stata inviato JSON non valido.Invalid JSON was submitted. Il corpo della risposta può contenere altre informazioni sulla risoluzione dell'errore.The response body might contain more information about how to resolve the error.
400400 Richiesta non validaBad request InvalidLogTypeInvalidLogType Il tipo di log specificato conteneva caratteri speciali o numeri.The log type specified contained special characters or numerics.
400400 Richiesta non validaBad request MissingApiVersionMissingApiVersion La versione API non è stata specificata.The API version wasn’t specified.
400400 Richiesta non validaBad request MissingContentTypeMissingContentType Il tipo di contenuto non è stato specificato.The content type wasn’t specified.
400400 Richiesta non validaBad request MissingLogTypeMissingLogType Il tipo di log dei valori non è stato specificato.The required value log type wasn’t specified.
400400 Richiesta non validaBad request UnsupportedContentTypeUnsupportedContentType Il tipo di contenuto non è stato impostato su application/json.The content type was not set to application/json.
403403 Accesso negatoForbidden InvalidAuthorizationInvalidAuthorization Il servizio non è riuscito ad autenticare la richiesta.The service failed to authenticate the request. Verificare che l'ID dell'area di lavoro e la chiave di connessione siano validi.Verify that the workspace ID and connection key are valid.
404404 Non trovatoNot Found L'URL specificato non è corretto o la richiesta è di dimensioni eccessive.Either the URL provided is incorrect, or the request is too large.
429429 Troppe richiesteToo Many Requests Il servizio sta ricevendo un elevato volume di dati dall'account.The service is experiencing a high volume of data from your account. Si prega di ripetere la richiesta più tardi.Please retry the request later.
500500 Internal Server ErrorInternal Server Error UnspecifiedErrorUnspecifiedError Errore interno del servizio.The service encountered an internal error. Si prega di ripetere la richiesta.Please retry the request.
503503 Servizio non disponibileService Unavailable ServiceUnavailableServiceUnavailable Il servizio non è attualmente disponibile per la ricezione delle richieste.The service currently is unavailable to receive requests. Si prega di ripetere la richiesta.Please retry your request.

Eseguire query sui datiQuery data

Per eseguire query sui dati inviati dall'API di raccolta dati HTTP di Monitoraggio di Azure, cercare i record con valore di Type uguale al valore LogType specificato, con l'aggiunta di _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. Usando ad esempio MyCustomLog verranno restituiti tutti i record con MyCustomLog_CL.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Richieste di esempioSample requests

Nelle sezioni successive sono disponibili esempi di come inviare dati all'API di raccolta dati HTTP di Monitoraggio di Azure usando diversi linguaggi di programmazione.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.

Per ogni esempio, seguire questa procedura per impostare le variabili per l'intestazione dell'autorizzazione:For each sample, do these steps to set the variables for the authorization header:

  1. Nel portale di Azure individuare l'area di lavoro Log Analytics.In the Azure portal, locate your Log Analytics workspace.
  2. Selezionare Impostazioni avanzate e quindi Origini connesse.Select Advanced Settings and then Connected Sources.
  3. A destra di ID area di lavoro selezionare l'icona di copia e quindi incollare l'ID come valore della variabile ID cliente.To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. A destra di Chiave primaria selezionare l'icona di copia e quindi incollare l'ID come valore della variabile Chiave condivisa.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

In alternativa è possibile modificare le variabili per il tipo di log e i dati JSON.Alternatively, you can change the variables for the log type and JSON data.

Esempio 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 = "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  

Esempio 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);
            }
        }
    }
}

Esempio 2 di PythonPython 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)

Alternative e considerazioniAlternatives and considerations

Sebbene l'API dell'agente di raccolta dati debba coprire la maggior parte delle proprie esigenze per raccogliere dati in formato libero nei log di Azure, esistono istanze in cui potrebbe essere necessaria un'alternativa per superare alcune delle limitazioni dell'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. Tutte le opzioni sono le seguenti: considerazioni principali:All your options are as follows, major considerations included:

AlternativaAlternative DescriptionDescription Ideale perBest suited for
Eventi personalizzati: inserimento basato su SDK nativo in Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, in genere instrumentato tramite un SDK all'interno dell'applicazione, offre la possibilità di inviare dati personalizzati tramite eventi personalizzati.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Dati generati all'interno dell'applicazione, ma non prelevati dall'SDK tramite uno dei tipi di dati predefiniti (richieste, dipendenze, eccezioni e così via).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).
  • Dati più spesso correlati ad altri dati dell'applicazione in Application InsightsData that is most often correlated to other application data in Application Insights
API dell'agente di raccolta dati nei log di monitoraggio di AzureData Collector API in Azure Monitor Logs L'API dell'agente di raccolta dati nei log di monitoraggio di Azure è un modo completamente aperto per inserire i dati.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. I dati formattati in un oggetto JSON possono essere inviati qui.Any data formatted in a JSON object can be sent here. Una volta inviato, verrà elaborato e disponibile nei log per la correlazione con altri dati nei log o con altri dati Application Insights.Once sent, it will be processed, and available in Logs to be correlated with other data in Logs or against other Application Insights data.

È abbastanza semplice caricare i dati come file in un BLOB BLOB di Azure, da dove questi file verranno elaborati e caricati in 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. Vedere questo articolo per un'implementazione di esempio di una pipeline di questo tipo.Please see this article for a sample implementation of such a pipeline.
  • Dati non necessariamente generati all'interno di un'applicazione instrumentata all'interno Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Gli esempi includono le tabelle di ricerca e dei fatti, i dati di riferimento, le statistiche pre-aggregate e così via.Examples include lookup and fact tables, reference data, pre-aggregated statistics, and so on.
  • Destinato ai dati a cui viene fatto riferimento incrociato rispetto ad altri dati di monitoraggio di Azure (Application Insights, altri tipi di dati dei log, Centro sicurezza, monitoraggio di Azure per contenitori/VM e così via).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).
Esplora dati di AzureAzure Data Explorer Azure Esplora dati (ADX) è la piattaforma dati che permette di Application Insights l'analisi e i log di monitoraggio di Azure.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Ora disponibile a livello generale ("GA"), l'uso della piattaforma dati nella sua forma non elaborata ti offre la flessibilità completa, ma che richiede il sovraccarico di gestione, sul cluster (RBAC, tasso di conservazione, schema e così via).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 offre molte Opzioni di inserimento, tra cui file CSV, TSV e JSON .ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Dati che non verranno correlati a tutti gli altri dati in Application Insights o log.Data that will not be correlated to any other data under Application Insights or Logs.
  • I dati che richiedono funzionalità avanzate di inserimento o elaborazione non sono oggi disponibili nei log di monitoraggio di Azure.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Passaggi successiviNext steps