Naplóadatok küldése az Azure Monitorba a HTTP Data Collector API használatával (elavult)

Ez a cikk bemutatja, hogyan küldhet naplóadatokat a HTTP Data Collector API-val egy REST API-ügyfélről az Azure Monitorba. Leírja, hogyan formázhatja a szkript vagy alkalmazás által gyűjtött adatokat, hogyan csatolhatja azokat egy kérelembe, és hogyan rendelkezhet az Azure Monitor által engedélyezett kéréssel. Példákat mutatunk be az Azure PowerShellre, a C#-ra és a Pythonra.

Megjegyzés:

Az Azure Monitor HTTP Data Collector API elavult, és 2026. 09. 14-én már nem fog működni. Ezt a Logs ingestion API váltotta fel.

Fogalmak

A HTTP Data Collector API használatával naplóadatokat küldhet egy Log Analytics-munkaterületre az Azure Monitorban bármely olyan ügyféltől, amely meghívhat EGY REST API-t. Az ügyfél lehet egy runbook az Azure Automationben, amely felügyeleti adatokat gyűjt az Azure-ból vagy egy másik felhőből, vagy egy alternatív felügyeleti rendszer, amely az Azure Monitort használja a naplóadatok konszolidálására és elemzésére.

A Log Analytics-munkaterület összes adata egy adott rekordtípusú rekordként van tárolva. Az adatokat úgy formázza, hogy a HTTP Data Collector API-nak több rekordként küldje el a JavaScript Object Notation (JSON) alkalmazásban. Az adatok elküldésekor a kérelem hasznos adatainak minden egyes rekordjához külön rekord jön létre az adattárban.

Kérés létrehozása

A HTTP Data Collector API használatához létre kell hoznia egy POST-kérést, amely tartalmazza a JSON-ban küldendő adatokat. A következő három tábla felsorolja az egyes kérésekhez szükséges attribútumokat. A cikk későbbi részében részletesebben ismertetjük az egyes attribútumokat.

Kérés URI-ja

Attribútum	Property
Method	POST
URI	<https:// CustomerId.ods.opinsights.azure.com/api/logs?api-version=2016-04-01>
Tartalomtípus	application/json

URI-paraméterek kérése

Parameter	Leírás
CustomerID (Ügyfél azonosítója)	A Log Analytics-munkaterület egyedi azonosítója.
Resource	Az API-erőforrás neve: /api/logs.
API-verzió	A kéréshez használni kívánt API verziója. A verzió jelenleg 2016-04-01.

Kérésfejlécek

Fejléc	Leírás
Authorization	Az engedélyezési aláírás. A cikk későbbi részében megtudhatja, hogyan hozhat létre HMAC-SHA256 fejlécet.
Naplótípus	Adja meg a beküldött adatok rekordtípusát. Csak betűket, számokat és aláhúzásjelet (_) tartalmazhat, és nem haladhatja meg a 100 karaktert.
x-ms-date	A kérelem feldolgozásának dátuma RFC 1123 formátumban.
x-ms-AzureResourceId	Annak az Azure-erőforrásnak az erőforrás-azonosítója, amelyhez az adatokat társítani kell. Feltölti a _ResourceId tulajdonságot, és lehetővé teszi az adatok erőforrás-környezetbeli lekérdezésekbe való belefoglalását. Ha ez a mező nincs megadva, az adatok nem lesznek belefoglalva az erőforrás-környezet lekérdezéseibe.
time-generated-field	Az adatelem időbélyegét tartalmazó adatmező neve. Ha megad egy mezőt, annak tartalma a TimeGenerated függvényhez lesz használva. Ha nem adja meg ezt a mezőt, a TimeGenerated alapértelmezett értéke az üzenet betöltésének időpontja. Az üzenetmező tartalmának az ISO 8601 YYYY-MM-DDThh:mm:ssZ formátumot kell követnie. Az idő generált értéke nem lehet 2 napnál régebbi a beérkezés előtt, vagy egy napnál hosszabb a jövőben. Ilyen esetben a rendszer az üzenet betöltésének idejét fogja használni.

Authorization

Az Azure Monitor HTTP Data Collector API-nak küldött kérésnek tartalmaznia kell egy engedélyezési fejlécet. A kérés hitelesítéséhez írja alá a kérést a kérést készítő munkaterület elsődleges vagy másodlagos kulcsával. Ezután adja át az aláírást a kérés részeként.

Az engedélyezési fejléc formátuma a következő:

Authorization: SharedKey <WorkspaceID>:<Signature>

A WorkspaceID a Log Analytics-munkaterület egyedi azonosítója. Az aláírás egy kivonatalapú üzenethitelesítési kód (HMAC), amely a kérésből lett létrehozva, majd az SHA256 algoritmussal kiszámítva. Ezt követően Base64 kódolással kódolhatja.

Ezzel a formátummal kódolhatja a SharedKey aláírási sztringet:

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

Íme egy példa egy aláírási sztringre:

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

Ha rendelkezik az aláírási sztringgel, az UTF-8 kódolású sztring HMAC-SHA256 algoritmusával kódolja, majd az eredményt Base64-ként kódolja. Használja ezt a formátumot:

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

A következő szakaszokban szereplő minták mintakódokkal rendelkeznek, amelyek segítenek létrehozni egy engedélyezési fejlécet.

Kérés törzse

Az üzenet törzsének JSON-ban kell lennie. Tartalmaznia kell egy vagy több rekordot a tulajdonságnévvel és értékpárokkal a következő formátumban. A tulajdonságnév csak betűket, számokat és aláhúzásjelet (_) tartalmazhat.

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

Egyetlen kérelemben több rekordot is kötegelhet az alábbi formátumban. Minden rekordnak azonos típusúnak kell lennie.

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

Rekord típusa és tulajdonságai

Egyéni rekordtípust határoz meg, amikor adatokat küld az Azure Monitor HTTP Data Collector API-val. Jelenleg nem írhat adatokat olyan meglévő rekordtípusokba, amelyeket más adattípusok és megoldások hoztak létre. Az Azure Monitor beolvassa a bejövő adatokat, majd létrehozza a megadott értékek adattípusainak megfelelő tulajdonságokat.

A Data Collector API-nak küldött minden kérésnek tartalmaznia kell egy napló típusú fejlécet a rekordtípus nevével. A _CL utótagot a rendszer automatikusan hozzáfűzi a megadott névhez, hogy megkülönböztesse a többi naplótípustól egyéni naplóként. Ha például a MyNewRecordType nevet adja meg, az Azure Monitor létrehoz egy rekordot MyNewRecordType_CL típussal. Ez segít biztosítani, hogy ne legyenek ütközések a felhasználó által létrehozott típusnevek és az aktuális vagy jövőbeli Microsoft-megoldásokban szállított nevek között.

Egy tulajdonság adattípusának azonosításához az Azure Monitor hozzáad egy utótagot a tulajdonság nevéhez. Ha egy tulajdonság null értéket tartalmaz, a tulajdonság nem szerepel a rekordban. Ez a táblázat a tulajdonság adattípusát és a megfelelő utótagot sorolja fel:

Tulajdonság adattípusa	Utótag
Sztring	_S
Boolean	_B
Dupla	_D
Dátum/idő	_T
GUID (sztringként tárolva)	_G

Megjegyzés:

A grafikus felhasználói felületnek tűnő sztringértékek a _g utótagot kapják, és GUID formátumban vannak formázva, még akkor is, ha a bejövő érték nem tartalmaz kötőjeleket. Például a "8145d822-13a7-44ad-859c-36f31a84f6dd" és a "8145d82213a744ad" A859c36f31a84f6dd" a következő formátumban van tárolva: "8145d822-13a7-44ad-859c-36f31a84f6dd". A két sztring között csak a névben szereplő _g és a kötőjelek beszúrása különbözik, ha nincsenek megadva a bemenetben.

Az Azure Monitor által az egyes tulajdonságokhoz használt adattípus attól függ, hogy az új rekord rekordtípusa már létezik-e.

• Ha a rekordtípus nem létezik, az Azure Monitor létrehoz egy újat a JSON-típus következtetésével az új rekord egyes tulajdonságainak adattípusának meghatározásához.
• Ha a rekordtípus létezik, az Azure Monitor új rekordot próbál létrehozni a meglévő tulajdonságok alapján. Ha az új rekord egyik tulajdonságának adattípusa nem egyezik meg, és nem konvertálható a meglévő típusra, vagy ha a rekord tartalmaz egy nem létező tulajdonságot, az Azure Monitor létrehoz egy új tulajdonságot, amely a megfelelő utótagot tartalmazza.

A következő beküldési bejegyzés például három tulajdonsággal, number_d, boolean_b és string_s rendelkező rekordot hozna létre:

Ha ezt a következő bejegyzést szeretné elküldeni, és az összes érték sztringként van formázva, a tulajdonságok nem változnak. Az értékeket meglévő adattípusokká alakíthatja.

Ha azonban ezt a következő beküldést teszi, az Azure Monitor létrehozza az új tulajdonságokat boolean_d és string_d. Ezeket az értékeket nem konvertálhatja.

Ha ezután elküldi a következő bejegyzést, a rekordtípus létrehozása előtt az Azure Monitor létrehoz egy három tulajdonságokkal, number_s, boolean_s és string_s rendelkező rekordot. Ebben a bejegyzésben a kezdeti értékek sztringként lesznek formázva:

Fenntartott tulajdonságok

A következő tulajdonságok fenntartottak, és nem használhatók egyéni rekordtípusban. Hibaüzenet jelenik meg, ha a hasznos adatok tartalmazzák az alábbi tulajdonságneveket:

• bérlő
• TimeGenerated
• RawData

Adatkorlátok

Az Azure Monitor adatgyűjtési API-nak közzétett adatokra bizonyos korlátozások vonatkoznak:

• Legfeljebb 30 MB postánként az Azure Monitor Data Collector API-ba. Ez egy bejegyzés méretkorlátja. Ha egy bejegyzés adatai nagyobbak, mint 30 MB, akkor az adatokat kisebb méretű adattömbökre kell felosztani, és egyidejűleg elküldeni őket.
• Mezőértékek esetén legfeljebb 32 KB. If the field value is greater than 32 KB, the data will be truncated.
• Egy adott típushoz legfeljebb 50 mező ajánlott. Ez az észszerű korlát a használati és keresési teljesítmény szempontjából.
• A Log Analytics-munkaterületeken lévő táblák legfeljebb 500 oszlopot támogatnak (a jelen cikk mezőinek is nevezik).
• Oszlopnevek legfeljebb 45 karakter hosszúságúak.

Visszatérési kódok

A HTTP-állapotkód 200 azt jelenti, hogy a kérés feldolgozásra érkezett. Ez azt jelzi, hogy a művelet sikeresen befejeződött.

A szolgáltatás által visszaadható állapotkódok teljes készlete az alábbi táblázatban található:

Kód	Status	Error code	Leírás
200	OK		A kérést sikeresen elfogadták.
400	Hibás kérés	InactiveCustomer	A munkaterület bezárult.
400	Hibás kérés	InvalidApiVersion	A megadott API-verziót a szolgáltatás nem ismerte fel.
400	Hibás kérés	InvalidCustomerId	A megadott munkaterület-azonosító érvénytelen.
400	Hibás kérés	InvalidDataFormat	Érvénytelen JSON lett elküldve. A válasz törzse további információkat tartalmazhat a hiba megoldásáról.
400	Hibás kérés	InvalidLogType	A megadott naplótípus speciális karaktereket vagy számokat tartalmazott.
400	Hibás kérés	MissingApiVersion	Az API-verzió nincs megadva.
400	Hibás kérés	MissingContentType	A tartalomtípus nincs megadva.
400	Hibás kérés	MissingLogType	A szükséges értéknapló-típus nincs megadva.
400	Hibás kérés	Nem támogatottContentType	A tartalomtípus nem lett beállítva alkalmazás/json értékre.
403	Forbidden	InvalidAuthorization	A szolgáltatás nem tudta hitelesíteni a kérést. Ellenőrizze, hogy a munkaterület azonosítója és a kapcsolatkulcs érvényes-e.
404	Nem található		A megadott URL-cím helytelen, vagy a kérés túl nagy.
429	Túl sok kérés		A szolgáltatás nagy mennyiségű adatot tapasztal a fiókjából. Később próbálkozzon újra a kéréssel.
500	Belső kiszolgálóhiba	UnspecifiedError	A szolgáltatás belső hibát észlelt. Próbálkozzon újra a kéréssel.
503	A szolgáltatás nem érhető el	ServiceUnavailable	A szolgáltatás jelenleg nem érhető el a kérések fogadásához. Próbálkozzon újra a kéréssel.

Adatok lekérdezése

Az Azure Monitor HTTP Data Collector API által küldött adatok lekérdezéséhez keressen olyan rekordokat, amelyek típusa megegyezik a megadott LogType értékkel, és hozzáfűzi az _CL. Ha például a MyCustomLogot használta, az összes rekordot visszaadja a következővelMyCustomLog_CL: .

Mintakérések

Ebben a szakaszban olyan minták találhatók, amelyek bemutatják, hogyan küldhet adatokat az Azure Monitor HTTP Data Collector API-nak különböző programozási nyelvek használatával.

Minden minta esetében állítsa be az engedélyezési fejléc változóit az alábbi lépésekkel:

1. Az Azure Portalon keresse meg a Log Analytics-munkaterületet.
2. Válassza ki az Ügynökök lehetőséget.
3. A munkaterület-azonosítótól jobbra válassza a Másolás ikont, majd illessze be az azonosítót az Ügyfélazonosító változó értékeként.
4. Az elsődleges kulcstól jobbra válassza a Másolás ikont, majd illessze be az azonosítót a Megosztott kulcs változó értékeként.

Másik lehetőségként módosíthatja a naplótípus és a JSON-adatok változóit.

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

Megjegyzés:

Ha Python 2-t használ, előfordulhat, hogy módosítania kell a sort: bytes_to_hash = bytes(string_to_hash, encoding="utf-8")–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;
  }

}

Alternatívák és szempontok

Bár a Data Collector API-nak a legtöbb igényét ki kell elégítenie, amikor szabad formátumú adatokat gyűjt az Azure-naplókba, alternatív megközelítésre lehet szükség az API bizonyos korlátainak leküzdéséhez. A lehetőségek, beleértve a főbb szempontokat, az alábbi táblázatban találhatók:

Alternative	Leírás	A legjobban a
Egyéni események: Natív SDK-alapú betöltés az Alkalmazás Elemzések	Az alkalmazás Elemzések, amely általában az alkalmazás SDK-ján keresztül van kialakítva, lehetővé teszi egyéni adatok egyéni eseményeken keresztüli küldését.	Az alkalmazásban létrehozott, de az SDK által nem felvett adatok az alapértelmezett adattípusok (kérések, függőségek, kivételek stb.) egyikén keresztül. Az Alkalmazás Elemzések más alkalmazásadataival leggyakrabban korrelált adatok.
Data Collector API az Azure Monitor-naplókban	Az Azure Monitor-naplók Data Collector API-ja teljesen nyitott módszer az adatok betöltésére. A JSON-objektumban formázott adatok elküldhetők ide. Az elküldése után a rendszer feldolgozja és elérhetővé teszi a Monitornaplókban, hogy korreláljon a monitornaplókban szereplő más adatokkal, vagy más alkalmazás Elemzések adatokkal. Elég egyszerű fájlként feltölteni az adatokat egy Azure Blob Storage-blobba, ahol a fájlokat feldolgozzák, majd feltöltik a Log Analyticsbe. A minta implementációért lásd : Adatfolyam létrehozása a Data Collector API-val.	Olyan adatok, amelyek nem feltétlenül jönnek létre egy alkalmazáson belül, amely az Application Elemzések rendszerezett. Ilyenek például a keresési és ténytáblák, a referenciaadatok, az előre összesített statisztikák stb. Más Azure Monitor-adatokra (alkalmazás-Elemzések, egyéb monitornapló-adattípusokra, Felhőhöz készült Defender, tárolóelemzésekre és virtuális gépekre stb.) hivatkozó adatok.
Azure Data Explorer	A nyilvánosan elérhető Azure Data Explorer az az adatplatform, amely az Application Elemzések Analyticset és az Azure Monitor-naplókat működteti. Az adatplatform nyers formában való használatával teljes rugalmasságot biztosít (de a felügyelet többletterhelését igényli) a fürt felett (Kubernetes szerepköralapú hozzáférés-vezérlés (RBAC), megőrzési arány, séma stb. Az Azure Data Explorer számos betöltési lehetőséget kínál, például CSV-, TSV- és JSON-fájlokat .	Azok az adatok, amelyek nem lesznek korrelálva más adatokkal az Alkalmazás Elemzések vagy a Naplók figyelése területen. Olyan adatok, amelyek speciális betöltési vagy feldolgozási képességeket igényelnek, amelyek jelenleg nem érhetők el az Azure Monitor-naplókban.

Következő lépések

• A Log Search API használatával adatokat kér le a Log Analytics-munkaterületről.

• További információ arról, hogyan hozhat létre adatfolyamot a Data Collector API-val egy Logic Apps-munkafolyamattal az Azure Monitorban.