Logboekgegevens naar Azure Monitor verzenden met de HTTP Data Collector-API (preview)
In dit artikel leest u hoe u de HTTP Data Collector-API gebruikt om logboekgegevens te verzenden naar Azure Monitor vanuit een REST API-client. 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 in openbare preview.
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 zijn in Azure Automation dat beheergegevens verzamelt uit Azure of een andere cloud, of het kan een alternatief beheersysteem zijn dat Gebruikmaakt van Azure Monitor om logboekgegevens te consolideren en analyseren.
Alle gegevens in de Log Analytics-werkruimte worden opgeslagen als een record met een bepaald recordtype. U maakt uw gegevens op om te verzenden naar de HTTP Data Collector-API als meerdere records in JSON (JavaScript Object Notation). 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 | Eigenschap |
|---|---|
| Methode | POST |
| URI | <https:// CustomerId.ods.opinsights.azure.com/api/logs?api-version=2016-04-01> |
| Inhoudstype | application/json |
URI-parameters aanvragen
| Parameter | Beschrijving |
|---|---|
| CustomerID | De unieke id voor de Log Analytics-werkruimte. |
| Resource | 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
| Header | Beschrijving |
|---|---|
| Autorisatie | De autorisatiehandtekening. Verderop in het artikel leest u hoe u een HMAC-SHA256-header maakt. |
| Log-Type | 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 7234-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 met de tijdstempel van het gegevensitem. 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. Opmerking: de door tijd gegenereerde waarde mag niet ouder zijn dan 2 dagen voor ontvangsttijd of de rij wordt verwijderd. |
Autorisatie
Elke aanvraag voor de HTTP Data Collector-API van Azure Monitor moet een autorisatieheader bevatten. Als u een aanvraag wilt verifiëren, moet u de aanvraag ondertekenen met de primaire of secundaire sleutel voor de werkruimte die de aanvraag doet. 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 handtekeningtekenreeks sharedkey 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.
Aanvraagbody
De hoofdtekst van het bericht moet in JSON staan. Het 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 Data Collector-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 deze 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.
Als u het gegevenstype van een eigenschap wilt 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. Deze tabel bevat het gegevenstype van de eigenschap en het bijbehorende achtervoegsel:
| Gegevenstype eigenschap | Achtervoegsel |
|---|---|
| Tekenreeks | _s |
| Booleaans | _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 deze 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 zou indienen, waarbij alle waarden die zijn opgemaakt als tekenreeksen, zouden de eigenschappen niet worden 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 oorspronkelijke waarden opgemaakt als een tekenreeks:
Gereserveerde eigenschappen
De volgende eigenschappen zijn gereserveerd en mogen niet worden gebruikt in een aangepast recordtype. U krijgt een foutmelding als uw nettolading een van deze eigenschapsnamen bevat:
- tenant
- TimeGenerated
- RawData
Gegevenslimieten
De gegevens die zijn gepost in de Api voor gegevensverzameling van Azure Monitor, 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 splitsen in kleinere segmenten en deze 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 weergegeven 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 de 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 groot aantal 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 de volgende secties vindt u voorbeelden die laten zien hoe u gegevens kunt verzenden naar de AZURE Monitor HTTP Data Collector-API met behulp van verschillende programmeertalen.
Stel voor elk voorbeeld de variabelen voor de autorisatieheader als volgt in:
- Zoek in de Azure Portal uw Log Analytics-werkruimte.
- Selecteer Agents-beheer.
- Selecteer rechts van werkruimte-id het pictogram Kopiëren en plak de id als de waarde van de variabele Klant-id .
- 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 de JSON-gegevens wijzigen.
Voorbeeld van 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#-voorbeeld
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);
}
}
}
}
Python-voorbeeld
Notitie
Als u Python 2 gebruikt, moet u mogelijk de regel wijzigen:bytes_to_hash = bytes(string_to_hash, encoding="utf-8") Aan 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-voorbeeld
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-vormgegevens verzamelt in Azure-logboeken, moet u mogelijk een alternatieve benadering vereisen 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 een systeemeigen SDK gebaseerde opname in Application Insights | Application Insights, meestal geïnstrueerd via een SDK in uw toepassing, biedt u de mogelijkheid om aangepaste gegevens te verzenden via aangepaste gebeurtenissen. |
|
| Gegevensverzamelaar-API in Azure Monitor-logboeken | De Data Collector-API in Azure Monitor-logboeken is een volledig open 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. |
|
| Azure Data Explorer | Azure Data Explorer, nu algemeen beschikbaar voor het publiek, is het gegevensplatform waarmee Application Insights Analytics- en Azure Monitor-logboeken worden gebruikt. Door het gegevensplatform in onbewerkte vorm te gebruiken, hebt u volledige flexibiliteit (maar de overhead van beheer nodig) over het cluster (Op rollen gebaseerd toegangsbeheer (Kubernetes), retentiepercentage, schema, enzovoort). Azure Data Explorer biedt veel opnameopties, waaronder CSV-, TSV- en JSON-bestanden. |
|
Volgende stappen
Gebruik de Log Search-API 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.