Logboekgegevens verzenden naar Azure Monitor met behulp van de HTTP Data Collector-API (afgeschaft)

In dit artikel leest u hoe u de HTTP Data Collector-API gebruikt om logboekgegevens vanuit een REST API-client naar Azure Monitor te verzenden. Hierin wordt beschreven hoe u gegevens opmaken die worden verzameld door uw script of toepassing, deze opnemen in een aanvraag en deze aanvraag laten geautoriseerd door Azure Monitor. We bieden voorbeelden voor Azure PowerShell, C# en Python.

Notitie

De AZURE Monitor HTTP Data Collector-API is afgeschaft en werkt vanaf 14-9-2026 niet meer. Deze is vervangen door de API voor logboekopname.

Concepten

U kunt de HTTP Data Collector-API gebruiken om logboekgegevens te verzenden naar een Log Analytics-werkruimte in Azure Monitor vanaf elke client die een REST API kan aanroepen. De client kan een runbook in Azure Automation zijn dat beheergegevens verzamelt uit Azure of een andere cloud, of het kan een alternatief beheersysteem zijn dat Gebruikmaakt van Azure Monitor om logboekgegevens samen te voegen en te analyseren.

Alle gegevens in de Log Analytics-werkruimte worden opgeslagen als een record met een bepaald recordtype. U kunt uw gegevens opmaken om naar de HTTP Data Collector-API te verzenden als meerdere records in JavaScript Object Notation (JSON). Wanneer u de gegevens verzendt, wordt er een afzonderlijke record gemaakt in de opslagplaats voor elke record in de nettolading van de aanvraag.

Een aanvraag maken

Als u de HTTP Data Collector-API wilt gebruiken, maakt u een POST-aanvraag die de gegevens bevat die moeten worden verzonden in JSON. De volgende drie tabellen bevatten de kenmerken die vereist zijn voor elke aanvraag. We beschrijven elk kenmerk verderop in het artikel.

Aanvraag-URI

Kenmerk	Eigenschappen
Wijze	POSTEN
URI	<https:// CustomerId.ods.opinsights.azure.com/api/logs?api-version=2016-04-01>
Inhoudstype	application/json

URI-parameters aanvragen

Parameter	Description
CustomerID	De unieke id voor de Log Analytics-werkruimte.
Bron	De naam van de API-resource: /api/logs.
API-versie	De versie van de API die met deze aanvraag moet worden gebruikt. Momenteel is de versie 2016-04-01.

Aanvraagheaders

Koptekst	Beschrijving
Autorisatie	De autorisatiehandtekening. Verderop in het artikel leest u hoe u een HMAC-SHA256-header maakt.
Logboektype	Geef het recordtype op van de gegevens die worden verzonden. Het mag alleen letters, cijfers en het onderstrepingsteken (_) bevatten en mag niet langer zijn dan 100 tekens.
x-ms-date	De datum waarop de aanvraag is verwerkt, in RFC 1123-indeling .
x-ms-AzureResourceId	De resource-id van de Azure-resource waaraan de gegevens moeten worden gekoppeld. Hiermee wordt de eigenschap _ResourceId ingevuld en kunnen de gegevens worden opgenomen in resourcecontextquery's . Als dit veld niet is opgegeven, worden de gegevens niet opgenomen in resourcecontextquery's.
tijd gegenereerd veld	De naam van een veld in de gegevens die de tijdstempel van het gegevensitem bevat. Als u een veld opgeeft, wordt de inhoud ervan gebruikt voor TimeGenerated. Als u dit veld niet opgeeft, is de standaardwaarde voor TimeGenerated het tijdstip waarop het bericht wordt opgenomen. De inhoud van het berichtveld moet de ISO 8601-indeling JJJJ-MM-DDThh:mm:ssZ volgen. De waarde Gegenereerde tijd kan niet ouder zijn dan 2 dagen voor ontvangsttijd of meer dan een dag in de toekomst. In dat geval wordt het tijdstip waarop het bericht wordt opgenomen, gebruikt.

Autorisatie

Elke aanvraag voor de AZURE Monitor HTTP Data Collector-API moet een autorisatieheader bevatten. Als u een aanvraag wilt verifiëren, ondertekent u de aanvraag met de primaire of secundaire sleutel voor de werkruimte die de aanvraag indient. Geef die handtekening vervolgens door als onderdeel van de aanvraag.

Dit is de indeling voor de autorisatieheader:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID is de unieke id voor de Log Analytics-werkruimte. Handtekening is een HMAC (Hash-based Message Authentication Code) die is samengesteld op basis van de aanvraag en vervolgens wordt berekend met behulp van het SHA256-algoritme. Vervolgens codeert u deze met base64-codering.

Gebruik deze indeling om de sharedKey-handtekeningtekenreeks te coderen:

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

Hier volgt een voorbeeld van een handtekeningtekenreeks:

POST\n1024\napplication/json\nx-ms-date:Mon, 04 Apr 2016 08:00:00 GMT\n/api/logs

Wanneer u de handtekeningtekenreeks hebt, codeert u deze met behulp van het HMAC-SHA256-algoritme op de UTF-8-gecodeerde tekenreeks en codeert u het resultaat vervolgens als Base64. Gebruik deze indeling:

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

De voorbeelden in de volgende secties bevatten voorbeeldcode om u te helpen bij het maken van een autorisatieheader.

Aanvraagtekst

De hoofdtekst van het bericht moet in JSON staan. Deze moet een of meer records bevatten met de eigenschapsnaam en waardeparen in de volgende indeling. De naam van de eigenschap mag alleen letters, cijfers en het onderstrepingsteken (_) bevatten.

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

U kunt meerdere records samenvoegen in één aanvraag met behulp van de volgende indeling. Alle records moeten hetzelfde recordtype hebben.

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

Recordtype en eigenschappen

U definieert een aangepast recordtype wanneer u gegevens verzendt via de AZURE Monitor HTTP-gegevensverzamelaar-API. Op dit moment kunt u geen gegevens schrijven naar bestaande recordtypen die zijn gemaakt door andere gegevenstypen en oplossingen. Azure Monitor leest de binnenkomende gegevens en maakt vervolgens eigenschappen die overeenkomen met de gegevenstypen van de waarden die u invoert.

Elke aanvraag voor de Data Collector-API moet een logboektype-header bevatten met de naam voor het recordtype. Het achtervoegsel _CL wordt automatisch toegevoegd aan de naam die u invoert om dit te onderscheiden van andere logboektypen als een aangepast logboek. Als u bijvoorbeeld de naam MyNewRecordType invoert, maakt Azure Monitor een record met het type MyNewRecordType_CL. Dit helpt ervoor te zorgen dat er geen conflicten zijn tussen door de gebruiker gemaakte typenamen en namen die worden verzonden in huidige of toekomstige Microsoft-oplossingen.

Om het gegevenstype van een eigenschap te identificeren, voegt Azure Monitor een achtervoegsel toe aan de naam van de eigenschap. Als een eigenschap een null-waarde bevat, wordt de eigenschap niet opgenomen in die record. In deze tabel ziet u het gegevenstype van de eigenschap en het bijbehorende achtervoegsel:

Gegevenstype eigenschap	Achtervoegsel
String	_s
Booleaanse waarde	_b
Dubbel	_d
Datum/tijd	_t
GUID (opgeslagen als een tekenreeks)	_g

Notitie

Tekenreekswaarden die GUID's lijken te zijn, krijgen het _g achtervoegsel en opgemaakt als een GUID, zelfs als de binnenkomende waarde geen streepjes bevat. Bijvoorbeeld: '8145d822-13a7-44ad-859c-36f31a84f6dd' en '8145d82213a744ad859c36f31a84f6dd' worden opgeslagen als '8145d822-13a7-44ad-859c-36f31a84f6dd'. De enige verschillen tussen deze en een andere tekenreeks zijn de _g in de naam en de invoeging van streepjes als ze niet zijn opgegeven in de invoer.

Het gegevenstype dat Azure Monitor voor elke eigenschap gebruikt, is afhankelijk van of het recordtype voor de nieuwe record al bestaat.

• Als het recordtype niet bestaat, maakt Azure Monitor een nieuw record met behulp van de JSON-typedeductie om het gegevenstype voor elke eigenschap voor de nieuwe record te bepalen.
• Als het recordtype bestaat, probeert Azure Monitor een nieuwe record te maken op basis van bestaande eigenschappen. Als het gegevenstype voor een eigenschap in de nieuwe record niet overeenkomt en niet kan worden geconverteerd naar het bestaande type, of als de record een eigenschap bevat die niet bestaat, maakt Azure Monitor een nieuwe eigenschap met het relevante achtervoegsel.

Met de volgende inzendingsvermelding wordt bijvoorbeeld een record gemaakt met drie eigenschappen, number_d, boolean_b en string_s:

Als u deze volgende vermelding indient, waarbij alle waarden die zijn opgemaakt als tekenreeksen, worden de eigenschappen niet gewijzigd. U kunt de waarden converteren naar bestaande gegevenstypen.

Maar als u deze volgende inzending maakt, maakt Azure Monitor de nieuwe eigenschappen boolean_d en string_d. U kunt deze waarden niet converteren.

Als u vervolgens de volgende vermelding indient voordat het recordtype wordt gemaakt, maakt Azure Monitor een record met drie eigenschappen, number_s, boolean_s en string_s. In deze vermelding wordt elk van de initiële waarden opgemaakt als een tekenreeks:

Gereserveerde eigenschappen

De volgende eigenschappen zijn gereserveerd en mogen niet worden gebruikt in een aangepast recordtype. Er wordt een foutbericht weergegeven als uw nettolading een van deze eigenschapsnamen bevat:

• tenant
• TimeGenerated
• RawData

Gegevenslimieten

De gegevens die zijn gepost in de Azure Monitor-gegevensverzamelings-API, zijn onderhevig aan bepaalde beperkingen:

• Maximaal 30 MB per post naar de Azure Monitor Data Collector-API. Dit is een groottelimiet voor één bericht. Als de gegevens uit één post groter zijn dan 30 MB, moet u de gegevens opsplitsen in kleinere segmenten en ze gelijktijdig verzenden.
• Maximum van 32 kB voor veldwaarden. Als een veldwaarde groter is dan 32 kB, worden de gegevens afgekapt.
• Aanbevolen maximum van 50 velden voor een bepaald type. Dit is een praktische limiet vanuit het oogpunt van bruikbaarheid en zoekervaring.
• Tabellen in Log Analytics-werkruimten ondersteunen slechts 500 kolommen (ook wel velden in dit artikel genoemd).
• Maximaal 45 tekens voor kolomnamen.

Retourcodes

De HTTP-statuscode 200 betekent dat de aanvraag is ontvangen voor verwerking. Dit geeft aan dat de bewerking is voltooid.

De volledige set statuscodes die door de service kunnen worden geretourneerd, wordt vermeld in de volgende tabel:

Code	Status	Foutcode	Beschrijving
200	OK		De aanvraag is geaccepteerd.
400	Ongeldige aanvraag	InactiveCustomer	De werkruimte is gesloten.
400	Ongeldige aanvraag	InvalidApiVersion	De API-versie die u hebt opgegeven, is niet herkend door de service.
400	Ongeldige aanvraag	InvalidCustomerId	De opgegeven werkruimte-id is ongeldig.
400	Ongeldige aanvraag	InvalidDataFormat	Er is een ongeldige JSON verzonden. De hoofdtekst van het antwoord bevat mogelijk meer informatie over het oplossen van de fout.
400	Ongeldige aanvraag	InvalidLogType	Het opgegeven logboektype bevat speciale tekens of numerieke tekens.
400	Ongeldige aanvraag	MissingApiVersion	De API-versie is niet opgegeven.
400	Ongeldige aanvraag	MissingContentType	Het inhoudstype is niet opgegeven.
400	Ongeldige aanvraag	MissingLogType	Het vereiste type waardelogboek is niet opgegeven.
400	Ongeldige aanvraag	Niet-ondersteundContentType	Het inhoudstype is niet ingesteld op application/json.
403	Verboden	InvalidAuthorization	De service kan de aanvraag niet verifiëren. Controleer of de werkruimte-id en verbindingssleutel geldig zijn.
404	Niet gevonden		De opgegeven URL is onjuist of de aanvraag is te groot.
429	Te veel aanvragen		De service ondervindt een grote hoeveelheid gegevens uit uw account. Probeer de aanvraag later opnieuw.
500	Interne serverfout	UnspecifiedError	Er is een interne fout opgetreden in de service. Probeer de aanvraag opnieuw.
503	Service niet beschikbaar	ServiceUnavailable	De service is momenteel niet beschikbaar voor het ontvangen van aanvragen. Probeer uw aanvraag opnieuw.

Querygegevens

Als u query's wilt uitvoeren op gegevens die zijn verzonden door de AZURE Monitor HTTP-gegevensverzamelaar-API, zoekt u naar records waarvan het type gelijk is aan de LogType-waarde die u hebt opgegeven en toegevoegd aan _CL. Als u bijvoorbeeld MyCustomLog hebt gebruikt, zou u alle records retourneren met MyCustomLog_CL.

Voorbeeldaanvragen

In deze sectie vindt u voorbeelden die laten zien hoe u gegevens verzendt naar de AZURE Monitor HTTP-gegevensverzamelaar-API met behulp van verschillende programmeertalen.

Stel voor elk voorbeeld de variabelen voor de autorisatieheader als volgt in:

1. Zoek in Azure Portal uw Log Analytics-werkruimte.
2. Selecteer agents.
3. Selecteer rechts van werkruimte-id het pictogram Kopiëren en plak de id als de waarde van de variabele Klant-id.
4. Selecteer rechts van de primaire sleutel het pictogram Kopiëren en plak de id als de waarde van de variabele Gedeelde sleutel .

U kunt ook de variabelen voor het logboektype en JSON-gegevens wijzigen.

Powershell

# 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"

# Optional name of a field that includes the timestamp for the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
$TimeStampField = ""


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

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

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

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

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

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

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

}

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

C#

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

				// If charset=utf-8 is part of the content-type header, the API call may return forbidden.
				System.Net.Http.HttpContent httpContent = new StringContent(json, Encoding.UTF8);
				httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
				Task<System.Net.Http.HttpResponseMessage> response = client.PostAsync(new Uri(url), httpContent);

				System.Net.Http.HttpContent responseContent = response.Result.Content;
				string result = responseContent.ReadAsStringAsync().Result;
				Console.WriteLine("Return Result: " + result);
			}
			catch (Exception excep)
			{
				Console.WriteLine("API Post Exception: " + excep.Message);
			}
		}
	}
}

Python

Notitie

Als u Python 2 gebruikt, moet u mogelijk de regel wijzigen: bytes_to_hash = bytes(string_to_hash, encoding="utf-8") tot en met bytes_to_hash = bytes(string_to_hash).encode("utf-8")

import json
import requests
import datetime
import hashlib
import hmac
import base64

# Update the customer ID to your Log Analytics workspace ID
customer_id = 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'

# For the shared key, use either the primary or the secondary Connected Sources client authentication key   
shared_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# The log type is the name of the event that is being submitted
log_type = 'WebMonitorTest'

# An example JSON web monitor object
json_data = [{
   "slot_ID": 12345,
    "ID": "5cdad72f-c848-4df0-8aaa-ffe033e75d57",
    "availability_Value": 100,
    "performance_Value": 6.954,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "true"
},
{   
    "slot_ID": 67890,
    "ID": "b6bee458-fb65-492e-996d-61c4d7fbb942",
    "availability_Value": 100,
    "performance_Value": 3.379,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "false"
}]
body = json.dumps(json_data)

#####################
######Functions######  
#####################

# Build the API signature
def build_signature(customer_id, shared_key, date, content_length, method, content_type, resource):
    x_headers = 'x-ms-date:' + date
    string_to_hash = method + "\n" + str(content_length) + "\n" + content_type + "\n" + x_headers + "\n" + resource
    bytes_to_hash = bytes(string_to_hash, encoding="utf-8")  
    decoded_key = base64.b64decode(shared_key)
    encoded_hash = base64.b64encode(hmac.new(decoded_key, bytes_to_hash, digestmod=hashlib.sha256).digest()).decode()
    authorization = "SharedKey {}:{}".format(customer_id,encoded_hash)
    return authorization

# Build and send a request to the POST API
def post_data(customer_id, shared_key, body, log_type):
    method = 'POST'
    content_type = 'application/json'
    resource = '/api/logs'
    rfc1123date = datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
    content_length = len(body)
    signature = build_signature(customer_id, shared_key, rfc1123date, content_length, method, content_type, resource)
    uri = 'https://' + customer_id + '.ods.opinsights.azure.com' + resource + '?api-version=2016-04-01'

    headers = {
        'content-type': content_type,
        'Authorization': signature,
        'Log-Type': log_type,
        'x-ms-date': rfc1123date
    }

    response = requests.post(uri,data=body, headers=headers)
    if (response.status_code >= 200 and response.status_code <= 299):
        print('Accepted')
    else:
        print("Response code: {}".format(response.status_code))

post_data(customer_id, shared_key, body, log_type)

Java

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.MediaType;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Calendar;
import java.util.TimeZone;
import java.util.Locale;

import static org.springframework.http.HttpHeaders.CONTENT_TYPE;

public class ApiExample {

  private static final String workspaceId = "xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
  private static final String sharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
  private static final 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
   */
  private static final String timestamp = "";
  private static final String json = "{\"name\": \"test\",\n" + "  \"id\": 1\n" + "}";
  private static final String RFC_1123_DATE = "EEE, dd MMM yyyy HH:mm:ss z";

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    String dateString = getServerTime();
    String httpMethod = "POST";
    String contentType = "application/json";
    String xmsDate = "x-ms-date:" + dateString;
    String resource = "/api/logs";
    String stringToHash = String
        .join("\n", httpMethod, String.valueOf(json.getBytes(StandardCharsets.UTF_8).length), contentType,
            xmsDate , resource);
    String hashedString = getHMAC256(stringToHash, sharedKey);
    String signature = "SharedKey " + workspaceId + ":" + hashedString;

    postData(signature, dateString, json);
  }

  private static String getServerTime() {
    Calendar calendar = Calendar.getInstance();
    SimpleDateFormat dateFormat = new SimpleDateFormat(RFC_1123_DATE, Locale.US);
    dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
    return dateFormat.format(calendar.getTime());
  }

  private static void postData(String signature, String dateString, String json) throws IOException {
    String url = "https://" + workspaceId + ".ods.opinsights.azure.com/api/logs?api-version=2016-04-01";
    HttpPost httpPost = new HttpPost(url);
    httpPost.setHeader("Authorization", signature);
    httpPost.setHeader(CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
    httpPost.setHeader("Log-Type", logName);
    httpPost.setHeader("x-ms-date", dateString);
    httpPost.setHeader("time-generated-field", timestamp);
    httpPost.setEntity(new StringEntity(json));
    try(CloseableHttpClient httpClient = HttpClients.createDefault()){
      HttpResponse response = httpClient.execute(httpPost);
      int statusCode = response.getStatusLine().getStatusCode();
      System.out.println("Status code: " + statusCode);
    }
  }

  private static String getHMAC256(String input, String key) throws InvalidKeyException, NoSuchAlgorithmException {
    String hash;
    Mac sha256HMAC = Mac.getInstance("HmacSHA256");
    Base64.Decoder decoder = Base64.getDecoder();
    SecretKeySpec secretKey = new SecretKeySpec(decoder.decode(key.getBytes(StandardCharsets.UTF_8)), "HmacSHA256");
    sha256HMAC.init(secretKey);
    Base64.Encoder encoder = Base64.getEncoder();
    hash = new String(encoder.encode(sha256HMAC.doFinal(input.getBytes(StandardCharsets.UTF_8))));
    return hash;
  }

}

Alternatieven en overwegingen

Hoewel de Data Collector-API het grootste deel van uw behoeften moet dekken wanneer u vrije gegevens verzamelt in Azure-logboeken, is het mogelijk dat u een alternatieve benadering nodig hebt om enkele van de beperkingen van de API te overwinnen. Uw opties, inclusief belangrijke overwegingen, worden vermeld in de volgende tabel:

Alternatief	Beschrijving	Meest geschikt voor
Aangepaste gebeurtenissen: op systeemeigen SDK gebaseerde opname in Application Insights	Application Insights, meestal geïnstrueerd via een SDK binnen uw toepassing, biedt u de mogelijkheid om aangepaste gegevens te verzenden via aangepaste gebeurtenissen.	Gegevens die in uw toepassing worden gegenereerd, maar niet door de SDK worden opgehaald via een van de standaardgegevenstypen (aanvragen, afhankelijkheden, uitzonderingen, enzovoort). Gegevens die het vaakst worden gecorreleerd met andere toepassingsgegevens in Application Insights.
Gegevensverzamelaar-API in Azure Monitor-logboeken	De Data Collector-API in Azure Monitor-logboeken is een volledig open-beëindigde manier om gegevens op te nemen. Alle gegevens die zijn opgemaakt in een JSON-object, kunnen hier worden verzonden. Nadat het is verzonden, wordt deze verwerkt en beschikbaar gemaakt in Monitorlogboeken om te worden gecorreleerd met andere gegevens in Monitorlogboeken of op basis van andere Application Insights-gegevens. Het is vrij eenvoudig om de gegevens als bestanden te uploaden naar een Azure Blob Storage-blob, waar de bestanden worden verwerkt en vervolgens worden geüpload naar Log Analytics. Zie Een gegevenspijplijn maken met de Data Collector-API voor een voorbeeldimplementatie.	Gegevens die niet noodzakelijkerwijs worden gegenereerd binnen een toepassing die is geïnstrueerd in Application Insights. Voorbeelden hiervan zijn opzoek- en feitentabellen, referentiegegevens, vooraf samengevoegde statistieken, enzovoort. Gegevens waarnaar wordt verwezen op basis van andere Azure Monitor-gegevens (Application Insights, andere gegevenstypen Logboeken bewaken, Defender voor Cloud, Container insights en virtuele machines, enzovoort).
Azure Data Explorer	Azure Data Explorer, nu algemeen beschikbaar voor het publiek, is het gegevensplatform dat Application Insights Analytics en Azure Monitor-logboeken mogelijk maakt. Door het gegevensplatform in de onbewerkte vorm te gebruiken, hebt u volledige flexibiliteit (maar de overhead van beheer vereist) over het cluster (op rollen gebaseerd toegangsbeheer (Kubernetes), retentiepercentage, schema, enzovoort). Azure Data Explorer biedt veel opnameopties, waaronder CSV-, TSV- en JSON-bestanden .	Gegevens die niet worden gecorreleerd met andere gegevens onder Application Insights of Monitor-logboeken. Gegevens waarvoor geavanceerde opname- of verwerkingsmogelijkheden zijn vereist die momenteel niet beschikbaar zijn in Azure Monitor-logboeken.

Volgende stappen

• Gebruik de API voor zoeken in logboeken om gegevens op te halen uit de Log Analytics-werkruimte.

• Meer informatie over het maken van een gegevenspijplijn met de Data Collector-API met behulp van een Logic Apps-werkstroom naar Azure Monitor.