Transmettre des données à Azure Monitor avec l’API Collecteur de données HTTP (préversion publique)Send log data to Azure Monitor with the HTTP Data Collector API (public preview)

Cet article vous montre comment utiliser l’API Collecte de données HTTP pour transmettre des données à Azure Monitor à partir d’un client 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. Il explique comment mettre en forme les données collectées par le script ou l’application, les inclure dans une requête et faire en sorte qu’Azure Monitor autorise cette requête.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. Il est illustré par des exemples pour PowerShell, C# et Python.Examples are provided for PowerShell, C#, and Python.

Notes

Cet article a récemment été mis à jour pour utiliser le terme journaux d’activité Azure Monitor au lieu de Log Analytics.This article was recently updated to use the term Azure Monitor logs instead of Log Analytics. Les données de journal sont toujours stockées dans un espace de travail Log Analytics, et elles sont toujours collectées et analysées par le même service Log Analytics.Log data is still stored in a Log Analytics workspace and is still collected and analyzed by the same Log Analytics service. Nous mettons la terminologie à jour pour mieux refléter le rôle des journaux d’activité dans Azure Monitor.We are updating the terminology to better reflect the role of logs in Azure Monitor. Pour plus d'informations, consultez Modifications de la terminologie d'Azure Monitor.See Azure Monitor terminology changes for details.

Notes

L’API Collecteur de données HTTP Azure Monitor est en préversion publique.The Azure Monitor HTTP Data Collector API is in public preview.

ConceptsConcepts

L’API Collecte de données HTTP permet d’ajouter des données de journal d’activité à un espace de travail Log Analytics dans Azure Monitor à partir de tout client pouvant appeler une 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. Il peut s’agir d’un runbook dans Azure Automation qui collecte les données de gestion à partir d’Azure ou d’un autre cloud, ou il peut s’agit d’un système de gestion alternatif utilisant Azure Monitor pour consolider et analyser les données de journal.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.

Toutes les données de l’espace de travail Log Analytics sont stockées en tant qu’enregistrement avec un type d’enregistrement particulier.All data in the Log Analytics workspace is stored as a record with a particular record type. Vous formatez vos données à transmettre à l’API Collecte de données HTTP en tant qu’enregistrements multiples dans JSON.You format your data to send to the HTTP Data Collector API as multiple records in JSON. Lorsque vous envoyez vos données, un enregistrement individuel est créé dans le référentiel pour chaque enregistrement dans la charge utile de la requête.When you submit the data, an individual record is created in the repository for each record in the request payload.

Présentation la collecte de données HTTP

Créer une demandeCreate a request

Pour utiliser l’API Collecte de données HTTP, il vous suffit de créer une requête POST qui inclut les données à envoyer dans JavaScript Objet 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). Les trois tableaux suivants répertorient les attributs requis pour chaque requête.The next three tables list the attributes that are required for each request. Nous décrivons chaque attribut de façon plus détaillée plus loin dans cet article.We describe each attribute in more detail later in the article.

URI de demandeRequest URI

AttributAttribute PropriétéProperty
MéthodeMethod POSTPOST
URIURI https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01https://<CustomerId>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01
Type de contenuContent type application/jsonapplication/json

Paramètres de l’URI de demandeRequest URI parameters

ParamètreParameter DescriptionDescription
CustomerIDCustomerID Identificateur unique de l’espace de travail Log Analytics.The unique identifier for the Log Analytics workspace.
RessourceResource Nom de ressource de l’API : / api/logs.The API resource name: /api/logs.
Version de l'APIAPI Version Version de l’API à utiliser avec cette demande.The version of the API to use with this request. Actuellement, il s’agit de 2016-04-01.Currently, it's 2016-04-01.

En-têtes de requêteRequest headers

En-têteHeader DescriptionDescription
AutorisationAuthorization Signature de l’autorisation.The authorization signature. Plus loin dans cet article, vous pouvez lire comment créer un en-tête HMAC-SHA256.Later in the article, you can read about how to create an HMAC-SHA256 header.
Log-TypeLog-Type Spécifiez le type d’enregistrement des données envoyées.Specify the record type of the data that is being submitted. Ne peut contenir que des lettres, des chiffres et des traits de soulignement () et ne doit pas dépasser 100 caractères.Can only contain letters, numbers, and underscore (), and may not exceed 100 characters.
x-ms-datex-ms-date Date à laquelle la requête a été traitée, au format RFC 1123.The date that the request was processed, in RFC 1123 format.
x-ms-AzureResourceIdx-ms-AzureResourceId ID de la ressource Azure à laquelle les données doivent être associées.Resource ID of the Azure resource the data should be associated with. Cette opération remplit la propriété _ResourceId et permet d’inclure les données dans des requêtes centrées sur la ressource.This populates the _ResourceId property and allows the data to be included in resource-context queries. Si ce champ n’est pas spécifié, les données ne sont pas incluses dans des requêtes centrées sur la ressource.If this field isn't specified, the data will not be included in resource-context queries.
time-generated-fieldtime-generated-field Nom d’un champ de données qui contient l’horodateur de l’élément de données.The name of a field in the data that contains the timestamp of the data item. Si vous spécifiez un champ, son contenu est utilisé pour TimeGenerated.If you specify a field then its contents are used for TimeGenerated. Si ce champ n’est pas spécifié, la valeur par défaut de TimeGenerated est l’heure d’ingestion du message.If this field isn’t specified, the default for TimeGenerated is the time that the message is ingested. Le contenu du champ de message doit suivre le format ISO 8601 AAAA-MM-JJThh:mm:ssZ.The contents of the message field should follow the ISO 8601 format YYYY-MM-DDThh:mm:ssZ.

AutorisationAuthorization

Toute demande adressée à l’API Collecte de données HTTP Azure Monitor doit inclure un en-tête d’autorisation.Any request to the Azure Monitor HTTP Data Collector API must include an authorization header. Pour authentifier une demande, vous devez la signer avec la clé primaire ou secondaire de l’espace de travail qui effectue la demande.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. Ensuite, transmettez cette signature dans le cadre de la demande.Then, pass that signature as part of the request.

Voici le format de l’en-tête d’autorisation :Here's the format for the authorization header:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID est l’identificateur unique de l’espace de travail Log Analytics.WorkspaceID is the unique identifier for the Log Analytics workspace. Signature est une clé HMAC construite à partir de la demande, puis calculée à l’aide de l’algorithme SHA256.Signature is a Hash-based Message Authentication Code (HMAC) that is constructed from the request and then computed by using the SHA256 algorithm. Ensuite, vous l’encodez à l’aide d’un encodage Base64.Then, you encode it by using Base64 encoding.

Utilisez ce format pour encoder la chaîne de signature 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";

Voici un exemple de chaîne de signature :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

Lorsque vous avez la chaîne de signature, encodez-la en utilisant l’algorithme HMAC-SHA256 sur la chaîne encodée en UTF-8, puis encodez le résultat en 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. Utilisez le format suivant :Use this format:

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

Les exemples fournis dans les sections suivantes comportent un exemple de code pour vous aider à créer un en-tête d’autorisation.The samples in the next sections have sample code to help you create an authorization header.

Corps de la demandeRequest body

Le corps du message doit être au format JSON.The body of the message must be in JSON. Il doit inclure un ou plusieurs enregistrements avec les paires nom de propriété/valeur au format suivant.It must include one or more records with the property name and value pairs in the following format. Le nom de la propriété peut contenir uniquement des lettres, des chiffres et des traits de soulignement ().The property name can only contain letters, numbers, and underscore ().

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

Vous pouvez regrouper plusieurs enregistrements par lot dans une seule requête en utilisant le format suivant.You can batch multiple records together in a single request by using the following format. Tous les enregistrements doivent être du même type.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"
    }
]

Type et propriétés d’enregistrementRecord type and properties

Vous définissez un type d’enregistrement personnalisé lorsque vous envoyez des données via l’API Collecte de données HTTP Azure Monitor.You define a custom record type when you submit data through the Azure Monitor HTTP Data Collector API. Actuellement, vous ne pouvez pas écrire de données dans des types d’enregistrements existants qui ont été créés par d’autres types de données et solutions.Currently, you can't write data to existing record types that were created by other data types and solutions. Azure Monitor lit les données entrantes, puis crée des propriétés correspondant aux types de données des valeurs que vous entrez.Azure Monitor reads the incoming data and then creates properties that match the data types of the values that you enter.

Chaque demande adressée à l’API Azure Monitor doit inclure un en-tête Log-Type avec le nom du type d’enregistrement.Each request to the Data Collector API must include a Log-Type header with the name for the record type. Le suffixe _CL est automatiquement ajouté au nom que vous entrez pour le distinguer d’autres types de journaux en tant que journal personnalisé.The suffix _CL is automatically appended to the name you enter to distinguish it from other log types as a custom log. Par exemple, si vous entrez le nom MyNewRecordType, Azure Monitor crée un enregistrement du type MyNewRecordType_CL.For example, if you enter the name MyNewRecordType, Azure Monitor creates a record with the type MyNewRecordType_CL. Cela évite tout conflit entre les noms de type créés par l’utilisateur et ceux fournis dans les solutions Microsoft actuelles ou futures.This helps ensure that there are no conflicts between user-created type names and those shipped in current or future Microsoft solutions.

Pour identifier le type de données d’une propriété, Azure Monitor ajoute un suffixe au nom de celle-ci.To identify a property's data type, Azure Monitor adds a suffix to the property name. Si une propriété contient une valeur null, elle n’est pas incluse dans cet enregistrement.If a property contains a null value, the property is not included in that record. Ce tableau répertorie les types de données de propriété et les suffixes correspondants :This table lists the property data type and corresponding suffix:

Type de données de propriétéProperty data type SuffixeSuffix
StringString _s_s
BooleanBoolean _b_b
DoubleDouble _d_d
Date/timeDate/time _t_t
GUID (stocké en tant que chaîne)GUID (stored as a string) _g_g

Le type de données que Azure Monitor utilise pour chaque propriété dépend de l’existence préalable ou non du type d’enregistrement pour le nouvel enregistrement.The data type that Azure Monitor uses for each property depends on whether the record type for the new record already exists.

  • Si le type d’enregistrement n’existe pas, Azure Monitor en crée un à l’aide de l’inférence de type JSON pour déterminer le type de données pour chaque propriété du nouvel enregistrement.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.
  • Si le type d’enregistrement existe, Azure Monitor tente de créer un enregistrement en fonction des propriétés existantes.If the record type does exist, Azure Monitor attempts to create a new record based on existing properties. Si le type de données d’une propriété dans le nouvel enregistrement ne correspond pas et ne peut pas être converti vers le type existant, ou si l’enregistrement contient une propriété inexistante, Azure Monitor crée une propriété portant le suffixe approprié.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.

Par exemple, l’entrée de soumission suivante créerait un enregistrement avec trois propriétés, number_d, boolean_b, et string_s :For example, this submission entry would create a record with three properties, number_d, boolean_b, and string_s:

Exemple d’enregistrement 1

Si vous envoyiez ensuite l’entrée suivante, avec toutes les valeurs mises en forme de chaînes, les propriétés ne changeraient pas.If you then submitted this next entry, with all values formatted as strings, the properties would not change. Ces valeurs peuvent être converties en types de données existants :These values can be converted to existing data types:

Exemple d’enregistrement 2

Mais, si vous faisiez ensuite l’envoi suivant, Azure Monitor créerait les propriétés boolean_d et string_d.But, if you then made this next submission, Azure Monitor would create the new properties boolean_d and string_d. Les valeurs suivantes ne peuvent pas être converties :These values can't be converted:

Exemple d’enregistrement 3

Si vous envoyiez ensuite l’entrée suivante, avant que la création du type d’enregistrement, Azure Monitor créerait un enregistrement avec trois propriétés, number_s, boolean_s 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. Dans cette entrée, toutes les valeurs initiales sont au format de chaîne :In this entry, each of the initial values is formatted as a string:

Exemple d’enregistrement 4

Propriétés réservéesReserved properties

Les propriétés suivantes sont réservées et ne doivent pas être utilisées dans un type d’enregistrement personnalisé.The following properties are reserved and should not be used in a custom record type. Vous recevrez une erreur si votre charge utile contient l’un de ces noms de propriété.You will receive an error if your payload includes any of these property names.

  • tenanttenant

Limites de donnéesData limits

Il existe certaines contraintes sur les données publiées sur l’API de collecte de données d’Azure Monitor.There are some constraints around the data posted to the Azure Monitor Data collection API.

  • Un maximum de 30 Mo par publication sur l’API de collecte de données d’Azure Monitor.Maximum of 30 MB per post to Azure Monitor Data Collector API. Il s’agit d’une limite de taille pour une publication unique.This is a size limit for a single post. Si les données d’une publication unique sont supérieures à 30 Mo, vous devrez fractionner les données en segments de plus petite taille et les envoyer simultanément.If the data from a single post that exceeds 30 MB, you should split the data up to smaller sized chunks and send them concurrently.
  • Maximum de 32 Ko pour les valeurs de champ.Maximum of 32 KB limit for field values. Si la valeur de champ est supérieure à 32 Ko, les données seront tronquées.If the field value is greater than 32 KB, the data will be truncated.
  • Le nombre maximal recommandé de champs pour un type donné est 50.Recommended maximum number of fields for a given type is 50. Il s’agit d’une limite pratique du point de vue de la facilité d’utilisation et de l’expérience de recherche.This is a practical limit from a usability and search experience perspective.
  • Une table d’un espace de travail Log Analytics ne supporte pas plus de 500 colonnes (appelé champ dans cet article).A table in a Log Analytics workspace only supports up to 500 columns (referred to as a field in this article).
  • Le nombre maximal de caractères pour le nom de colonne est 500.The maximum number of characters for the column name is 500.

Codes de retourReturn codes

Le code d’état HTTP 200 signifie que la demande a été reçue et doit être traitée.The HTTP status code 200 means that the request has been received for processing. Cela indique que l’opération a été accomplie avec succès.This indicates that the operation completed successfully.

Ce tableau répertorie l’ensemble complet de codes d’état que le service peut retourner :This table lists the complete set of status codes that the service might return:

CodeCode StatutStatus Code d'erreurError code DescriptionDescription
200200 OKOK La demande a été acceptée.The request was successfully accepted.
400400 Demande incorrecteBad request InactiveCustomerInactiveCustomer L’espace de travail a été fermé.The workspace has been closed.
400400 Demande incorrecteBad request InvalidApiVersionInvalidApiVersion La version d’API que vous avez spécifiée n’est pas reconnue par le service.The API version that you specified was not recognized by the service.
400400 Demande incorrecteBad request InvalidCustomerIdInvalidCustomerId L’ID d’espace de travail spécifié n’est pas valide.The workspace ID specified is invalid.
400400 Demande incorrecteBad request InvalidDataFormatInvalidDataFormat Un JSON non valide a été envoyé.Invalid JSON was submitted. Il se peut que le corps de la réponse contiennent des informations supplémentaires sur la manière de résoudre l’erreur.The response body might contain more information about how to resolve the error.
400400 Demande incorrecteBad request InvalidLogTypeInvalidLogType Le type de journal spécifié contient des caractères spéciaux ou numériques.The log type specified contained special characters or numerics.
400400 Demande incorrecteBad request MissingApiVersionMissingApiVersion La version de l’API n’était pas spécifiée.The API version wasn’t specified.
400400 Demande incorrecteBad request MissingContentTypeMissingContentType Le type de contenu n’était pas spécifié.The content type wasn’t specified.
400400 Demande incorrecteBad request MissingLogTypeMissingLogType Le type de journal de valeur requis n’était pas spécifié.The required value log type wasn’t specified.
400400 Demande incorrecteBad request UnsupportedContentTypeUnsupportedContentType Le type de contenu n’était pas défini sur application/json.The content type was not set to application/json.
403403 InterditForbidden InvalidAuthorizationInvalidAuthorization Le serveur n’a pas pu authentifier la demande.The service failed to authenticate the request. Vérifiez que la clé de connexion et l’ID de l’espace de travail sont valides.Verify that the workspace ID and connection key are valid.
404404 IntrouvableNot Found L’URL fournie est incorrecte, ou la demande est trop grande.Either the URL provided is incorrect, or the request is too large.
429429 Trop de demandesToo Many Requests Le service reçoit un volume important de données à partir de votre compte.The service is experiencing a high volume of data from your account. Relancez la requête ultérieurement.Please retry the request later.
500500 Erreur interne du serveurInternal Server Error UnspecifiedErrorUnspecifiedError Le service a rencontré une erreur interne.The service encountered an internal error. Relancez la requête.Please retry the request.
503503 Service indisponibleService Unavailable ServiceUnavailableServiceUnavailable Le service est actuellement indisponible pour recevoir des demandes.The service currently is unavailable to receive requests. Relancez la requête.Please retry your request.

Interroger des donnéesQuery data

Pour interroger des données soumises par l’API Collecte de données HTTP Azure Monitor, recherchez des enregistrements dont la valeur Type correspond à la valeur LogType que vous avez spécifiée, assortie de _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. Par exemple, si vous avez utilisé MyCustomLog, vous devriez retourner tous les enregistrements avec MyCustomLog_CL.For example, if you used MyCustomLog, then you'd return all records with MyCustomLog_CL.

Exemples de demandesSample requests

Les sections suivantes contiennent des exemples montrant comment envoyer des données à l’API Collecte de données HTTP Azure Monitor à l’aide de différents langages de programmation.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.

Pour chaque exemple, procédez comme suit pour définir les variables de l’en-tête d’autorisation :For each sample, do these steps to set the variables for the authorization header:

  1. Dans le portail Azure, recherchez votre espace de travail Log Analytics.In the Azure portal, locate your Log Analytics workspace.
  2. Sélectionnez Paramètres avancés, puis Sources connectées.Select Advanced Settings and then Connected Sources.
  3. À droite de ID de l’espace de travail, sélectionnez l’icône de copie, puis collez l’ID en tant que valeur de la variable ID client.To the right of Workspace ID, select the copy icon, and then paste the ID as the value of the Customer ID variable.
  4. À droite de Clé primaire, sélectionnez l’icône de copie, puis collez l’ID en tant que valeur de la variable Clé partagée.To the right of Primary Key, select the copy icon, and then paste the ID as the value of the Shared Key variable.

Vous pouvez également modifier les variables pour le type de journal et les données JSON.Alternatively, you can change the variables for the log type and JSON data.

Exemple de code PowerShellPowerShell sample

# Replace with your Workspace ID
$CustomerId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"  

# Replace with your Primary Key
$SharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Specify the name of the record type that you'll be creating
$LogType = "MyRecordType"

# You can use an optional field to specify the timestamp from the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
$TimeStampField = ""


# Create two records with the same set of properties to create
$json = @"
[{  "StringValue": "MyString1",
    "NumberValue": 42,
    "BooleanValue": true,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "9909ED01-A74C-4874-8ABF-D2678E3AE23D"
},
{   "StringValue": "MyString2",
    "NumberValue": 43,
    "BooleanValue": false,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "8809ED01-A74C-4874-8ABF-D2678E3AE23D"
}]
"@

# Create the function to create the authorization signature
Function Build-Signature ($customerId, $sharedKey, $date, $contentLength, $method, $contentType, $resource)
{
    $xHeaders = "x-ms-date:" + $date
    $stringToHash = $method + "`n" + $contentLength + "`n" + $contentType + "`n" + $xHeaders + "`n" + $resource

    $bytesToHash = [Text.Encoding]::UTF8.GetBytes($stringToHash)
    $keyBytes = [Convert]::FromBase64String($sharedKey)

    $sha256 = New-Object System.Security.Cryptography.HMACSHA256
    $sha256.Key = $keyBytes
    $calculatedHash = $sha256.ComputeHash($bytesToHash)
    $encodedHash = [Convert]::ToBase64String($calculatedHash)
    $authorization = 'SharedKey {0}:{1}' -f $customerId,$encodedHash
    return $authorization
}


# Create the function to create and post the request
Function Post-LogAnalyticsData($customerId, $sharedKey, $body, $logType)
{
    $method = "POST"
    $contentType = "application/json"
    $resource = "/api/logs"
    $rfc1123date = [DateTime]::UtcNow.ToString("r")
    $contentLength = $body.Length
    $signature = Build-Signature `
        -customerId $customerId `
        -sharedKey $sharedKey `
        -date $rfc1123date `
        -contentLength $contentLength `
        -method $method `
        -contentType $contentType `
        -resource $resource
    $uri = "https://" + $customerId + ".ods.opinsights.azure.com" + $resource + "?api-version=2016-04-01"

    $headers = @{
        "Authorization" = $signature;
        "Log-Type" = $logType;
        "x-ms-date" = $rfc1123date;
        "time-generated-field" = $TimeStampField;
    }

    $response = Invoke-WebRequest -Uri $uri -Method $method -ContentType $contentType -Headers $headers -Body $body -UseBasicParsing
    return $response.StatusCode

}

# Submit the data to the API endpoint
Post-LogAnalyticsData -customerId $customerId -sharedKey $sharedKey -body ([System.Text.Encoding]::UTF8.GetBytes($json)) -logType $logType  

Exemple de code 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);
            }
        }
    }
}

Exemple de 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)

Alternatives et considérationsAlternatives and considerations

Bien que l’API de collecte de données soit censée répondre à la plupart de vos besoins pour collecter des données de forme libre dans les journaux Azure, il existe des instances où une alternative peut être nécessaire pour pallier certaines limitations de l’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. Toutes vos options sont les suivantes, considérations principales incluses :All your options are as follows, major considerations included:

AlternativeAlternative DescriptionDescription Idéale pourBest suited for
Événements personnalisés : Ingestion native basée sur le Kit de développement logiciel (SDK) dans Application InsightsCustom events: Native SDK-based ingestion in Application Insights Application Insights, généralement instrumenté via un Kit de développement logiciel (SDK) dans votre application, vous permet d’envoyer des données personnalisées par le biais d’événements personnalisés.Application Insights, typically instrumented through an SDK within your application, offers the ability for you to send custom data through Custom Events.
  • Données qui sont générées dans votre application, mais non récupérées par le Kit de développement logiciel (SDK) via un des types de données par défaut (par ex. : requêtes, dépendances, exceptions, etc.).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).
  • Données qui sont plus souvent corrélées à d’autres données d’application dans Application InsightsData that is most often correlated to other application data in Application Insights
API de collecte de données dans les journaux Azure MonitorData Collector API in Azure Monitor Logs L’API de collecte de données dans les journaux Azure Monitor est une méthode d’ingestion de données complètement flexible.The Data Collector API in Azure Monitor Logs is a completely open-ended way to ingest data. Toutes les données mises en forme dans un objet JSON peuvent être envoyées ici.Any data formatted in a JSON object can be sent here. Une fois envoyées, elles sont traitées et mises à disposition dans des journaux pour être corrélées à d’autres données de journaux ou par rapport à d’autres données 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.

Il est relativement facile de charger les données sous forme de fichiers dans un objet blob Azure Blob, ces fichiers seront alors traités et chargés dans 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. Consultez cet article pour un exemple d’implémentation de ce pipeline.Please see this article for a sample implementation of such a pipeline.
  • Données qui ne sont pas nécessairement générées dans une application instrumentée dans Application Insights.Data that is not necessarily generated within an application instrumented within Application Insights.
  • Les exemples incluent les tables de consultations et de faits, les données de référence, les statistiques pré-agrégées, etc.Examples include lookup and fact tables, reference data, pre-aggregated statistics, and so on.
  • Conçu pour les données qui seront référencées de manière croisée par rapport à d’autres données Azure Monitor (par exemple, Application Insights, autres types de données de journaux, Security Center, Azure Monitor pour conteneurs/machines virtuelles, etc.).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).
Explorateur de données AzureAzure Data Explorer Azure Data Explorer (ADX) est la plateforme de données sur laquelle s’appuient Application Insights Analytics et les journaux Azure Monitor.Azure Data Explorer (ADX) is the data platform that powers Application Insights Analytics and Azure Monitor Logs. Maintenant à la disposition générale, l’utilisation de la plateforme de données dans sa forme brute vous offre une flexibilité complète (mais implique une surcharge de gestion) sur le cluster (RBAC, taux de conservation, schéma, etc.).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 propose de nombreuses options d’ingestion, notamment des fichiers CSV, TSV et JSON.ADX provides many ingestion options including CSV, TSV, and JSON files.
  • Données qui ne seront pas corrélées à d’autres données dans Application Insights ou les journaux.Data that will not be correlated to any other data under Application Insights or Logs.
  • Données nécessitant des fonctionnalités d’ingestion ou de traitement avancées non disponibles actuellement dans les journaux Azure Monitor.Data requiring advanced ingestion or processing capabilities not today available in Azure Monitor Logs.

Étapes suivantesNext steps