Skicka loggdata till Azure Monitor med API för HTTP-datainsamling (förhandsversion)
Den här artikeln visar hur du använder HTTP Data Collector-API:et för att skicka loggdata till Azure Monitor från en REST API-klient. Den beskriver hur du formaterar data som samlas in av ditt skript eller program, inkluderar dem i en begäran och får den begäran auktoriserad av Azure Monitor. Vi tillhandahåller exempel för Azure PowerShell, C# och Python.
Anteckning
AZURE Monitor HTTP Data Collector-API:et finns i offentlig förhandsversion.
Begrepp
Du kan använda API:et FÖR HTTP-datainsamlare för att skicka loggdata till en Log Analytics-arbetsyta i Azure Monitor från alla klienter som kan anropa ett REST-API. Klienten kan vara en runbook i Azure Automation som samlar in hanteringsdata från Azure eller ett annat moln, eller ett alternativt hanteringssystem som använder Azure Monitor för att konsolidera och analysera loggdata.
Alla data på Log Analytics-arbetsytan lagras som en post med en viss posttyp. Du formaterar dina data som ska skickas till HTTP Data Collector-API:et som flera poster i JavaScript Object Notation (JSON). När du skickar data skapas en enskild post i lagringsplatsen för varje post i nyttolasten för begäran.
Skapa en begäran
Om du vill använda API:et för HTTP-datainsamlare skapar du en POST-begäran som innehåller de data som ska skickas i JSON. I de följande tre tabellerna visas de attribut som krävs för varje begäran. Vi beskriver varje attribut mer detaljerat senare i artikeln.
URI för förfrågan
| Attribut | Egenskap |
|---|---|
| Metod | POST |
| URI | <https:// CustomerId.ods.opinsights.azure.com/api/logs?api-version=2016-04-01> |
| Innehållstyp | application/json |
Begärande-URI-parametrar
| Parameter | Beskrivning |
|---|---|
| CustomerID | Den unika identifieraren för Log Analytics-arbetsytan. |
| Resurs | API-resursnamnet: /api/logs. |
| API-version | Den version av API:et som ska användas med den här begäran. För närvarande är versionen 2016-04-01. |
Begärandehuvuden
| Huvud | Beskrivning |
|---|---|
| Auktorisering | Auktoriseringssignaturen. Senare i artikeln kan du läsa om hur du skapar en HMAC-SHA256-rubrik. |
| Log-Type | Ange posttypen för de data som skickas. Den får bara innehålla bokstäver, siffror och understreck (_) och får inte överstiga 100 tecken. |
| x-ms-date | Det datum då begäran bearbetades i RFC 7234-format. |
| x-ms-AzureResourceId | Resurs-ID för Den Azure-resurs som data ska associeras med. Den fyller i egenskapen _ResourceId och tillåter att data inkluderas i frågor med resurskontext . Om det här fältet inte anges inkluderas inte data i frågor med resurskontext. |
| tidsgenererat fält | Namnet på ett fält i data som innehåller tidsstämpeln för dataobjektet. Om du anger ett fält används dess innehåll för TimeGenerated. Om du inte anger det här fältet är standardvärdet för TimeGenerated den tid då meddelandet matas in. Innehållet i meddelandefältet ska följa ISO 8601-formatet ÅÅÅÅ-MM-DDThh:mm:ssZ. Obs! Det tidsgenererade värdet får inte vara äldre än 3 dagar före mottagen tid, annars tas raden bort. |
Auktorisering
Alla förfrågningar till API:et för HTTP-datainsamlare i Azure Monitor måste innehålla ett auktoriseringshuvud. Om du vill autentisera en begäran signerar du begäran med antingen den primära eller den sekundära nyckeln för arbetsytan som gör begäran. Skicka sedan signaturen som en del av begäran.
Här är formatet för auktoriseringshuvudet:
Authorization: SharedKey <WorkspaceID>:<Signature>
WorkspaceID är den unika identifieraren för Log Analytics-arbetsytan. Signature är en Hash-baserad kod för meddelandeautentisering (HMAC) som konstrueras från begäran och sedan beräknas med hjälp av SHA256-algoritmen. Sedan kodar du den med hjälp av Base64-kodning.
Använd det här formatet för att koda signatursträngen SharedKey :
StringToSign = VERB + "\n" +
Content-Length + "\n" +
Content-Type + "\n" +
"x-ms-date:" + x-ms-date + "\n" +
"/api/logs";
Här är ett exempel på en signatursträng:
POST\n1024\napplication/json\nx-ms-date:Mon, 04 Apr 2016 08:00:00 GMT\n/api/logs
När du har signatursträngen kodar du den med hjälp av HMAC-SHA256-algoritmen på DEN UTF-8-kodade strängen och kodar sedan resultatet som Base64. Använd det här formatet:
Signature=Base64(HMAC-SHA256(UTF8(StringToSign)))
Exemplen i nästa avsnitt innehåller exempelkod som hjälper dig att skapa en auktoriseringsrubrik.
Begärandetext
Meddelandets brödtext måste vara i JSON. Den måste innehålla en eller flera poster med egenskapsnamn och värdepar i följande format. Egenskapsnamnet får bara innehålla bokstäver, siffror och understreck (_).
[
{
"property 1": "value1",
"property 2": "value2",
"property 3": "value3",
"property 4": "value4"
}
]
Du kan gruppera flera poster i en enda begäran med hjälp av följande format. Alla poster måste ha samma posttyp.
[
{
"property 1": "value1",
"property 2": "value2",
"property 3": "value3",
"property 4": "value4"
},
{
"property 1": "value1",
"property 2": "value2",
"property 3": "value3",
"property 4": "value4"
}
]
Posttyp och egenskaper
Du definierar en anpassad posttyp när du skickar data via AZURE Monitor HTTP Data Collector API. För närvarande kan du inte skriva data till befintliga posttyper som har skapats av andra datatyper och lösningar. Azure Monitor läser inkommande data och skapar sedan egenskaper som matchar datatyperna för de värden som du anger.
Varje begäran till API:et för datainsamlaren måste innehålla ett Log-Type-huvud med namnet på posttypen. Suffixet _CL läggs automatiskt till det namn som du anger för att skilja det från andra loggtyper som en anpassad logg. Om du till exempel anger namnet MyNewRecordType skapar Azure Monitor en post med typen MyNewRecordType_CL. Detta säkerställer att det inte finns några konflikter mellan användarskapade typnamn och de som levereras i aktuella eller framtida Microsoft-lösningar.
För att identifiera en egenskaps datatyp lägger Azure Monitor till ett suffix i egenskapsnamnet. Om en egenskap innehåller ett null-värde inkluderas inte egenskapen i posten. I den här tabellen visas egenskapens datatyp och motsvarande suffix:
| Egenskapsdatatyp | Suffix |
|---|---|
| Sträng | _s |
| Boolesk | _b |
| Double | _d |
| Datum/tid | _t |
| GUID (lagras som en sträng) | _g |
Anteckning
Strängvärden som verkar vara GUID får _g suffix och formateras som ett GUID, även om det inkommande värdet inte innehåller bindestreck. Till exempel både "8145d822-13a7-44ad-859c-36f31a84f6dd" och "8145d82213a744ad859c36f31a84f6dd" lagras som "8145d822-13a7-44ad-859c-36f31a84f6dd". De enda skillnaderna mellan den här och en annan sträng är _g i namnet och infogningen av bindestreck om de inte anges i indata.
Den datatyp som Azure Monitor använder för varje egenskap beror på om posttypen för den nya posten redan finns.
- Om posttypen inte finns skapar Azure Monitor en ny med hjälp av JSON-typinferensen för att fastställa datatypen för varje egenskap för den nya posten.
- Om posttypen finns försöker Azure Monitor skapa en ny post baserat på befintliga egenskaper. Om datatypen för en egenskap i den nya posten inte matchar och inte kan konverteras till den befintliga typen, eller om posten innehåller en egenskap som inte finns, skapar Azure Monitor en ny egenskap som har relevant suffix.
Följande inlämningspost skulle till exempel skapa en post med tre egenskaper, number_d, boolean_b och string_s:
Om du skulle skicka nästa post, med alla värden formaterade som strängar, skulle egenskaperna inte ändras. Du kan konvertera värdena till befintliga datatyper.
Men om du sedan gör nästa inlämning skapar Azure Monitor de nya egenskaperna boolean_d och string_d. Du kan inte konvertera dessa värden.
Om du sedan skickar följande post, innan posttypen skapas, skapar Azure Monitor en post med tre egenskaper, number_s, boolean_s och string_s. I den här posten formateras var och en av de inledande värdena som en sträng:
Reserverade egenskaper
Följande egenskaper är reserverade och bör inte användas i en anpassad posttyp. Du får ett felmeddelande om nyttolasten innehåller något av följande egenskapsnamn:
- tenant
- TimeGenerated
- RawData
Databegränsningar
De data som publiceras i Azure Monitor-API:et för datainsamling omfattas av vissa begränsningar:
- Högst 30 MB per post till Azure Monitor Data Collector API. Det här är en storleksgräns för ett enda inlägg. Om data från ett enda inlägg överskrider 30 MB bör du dela upp data i mindre segment och skicka dem samtidigt.
- Maximalt 32 kB för fältvärden. Om fältvärdet är större än 32 kB kommer data att trunkeras.
- Rekommenderat maximalt 50 fält för en viss typ. Detta är en praktisk gräns med tanke på användbarhet och sökfunktion.
- Tabeller i Log Analytics-arbetsytor stöder endast upp till 500 kolumner (kallas fält i den här artikeln).
- Högst 45 tecken för kolumnnamn.
Returkoder
HTTP-statuskoden 200 innebär att begäran har tagits emot för bearbetning. Detta indikerar att åtgärden har slutförts.
Den fullständiga uppsättningen statuskoder som tjänsten kan returnera visas i följande tabell:
| Kod | Status | Felkod | Beskrivning |
|---|---|---|---|
| 200 | OK | Begäran godkändes. | |
| 400 | Felaktig begäran | InactiveCustomer | Arbetsytan har stängts. |
| 400 | Felaktig begäran | InvalidApiVersion | Den API-version som du angav kändes inte igen av tjänsten. |
| 400 | Felaktig begäran | InvalidCustomerId | Det angivna arbetsyte-ID:t är ogiltigt. |
| 400 | Felaktig begäran | InvalidDataFormat | En ogiltig JSON skickades. Svarstexten kan innehålla mer information om hur du löser felet. |
| 400 | Felaktig begäran | InvalidLogType | Den angivna loggtypen innehöll specialtecken eller numeriska tecken. |
| 400 | Felaktig begäran | MissingApiVersion | API-versionen har inte angetts. |
| 400 | Felaktig begäran | MissingContentType | Innehållstypen har inte angetts. |
| 400 | Felaktig begäran | MissingLogType | Den värdeloggtyp som krävs har inte angetts. |
| 400 | Felaktig begäran | UnsupportedContentType | Innehållstypen har inte angetts till application/json. |
| 403 | Förbjudet | InvalidAuthorization | Det gick inte att autentisera begäran. Kontrollera att arbetsytans ID och anslutningsnyckel är giltiga. |
| 404 | Hittades inte | Antingen är den angivna URL:en felaktig eller så är begäran för stor. | |
| 429 | För många begäranden | Tjänsten har stora mängder data från ditt konto. Försök igen senare. | |
| 500 | Internt serverfel | UnspecifiedError | Tjänsten påträffade ett internt fel. Försök igen. |
| 503 | Tjänsten är inte tillgänglig | ServiceUnavailable | Tjänsten är för närvarande inte tillgänglig för att ta emot begäranden. Försök igen. |
Söka i data
Om du vill köra frågor mot data som skickas av AZURE Monitor HTTP Data Collector-API:et söker du efter poster vars typ är lika med det LogType-värde som du angav och lade till med _CL. Om du till exempel använde MyCustomLog skulle du returnera alla poster med MyCustomLog_CL.
Exempelbegäranden
I nästa avsnitt hittar du exempel som visar hur du skickar data till AZURE Monitor HTTP Data Collector API med hjälp av olika programmeringsspråk.
För varje exempel anger du variablerna för auktoriseringshuvudet genom att göra följande:
- Leta upp Log Analytics-arbetsytan i Azure Portal.
- Välj Agenthantering.
- Till höger om arbetsytans ID väljer du ikonen Kopiera och klistrar sedan in ID:t som värdet för variabeln Kund-ID .
- Till höger om Primär nyckel väljer du ikonen Kopiera och klistrar sedan in ID:t som värdet för variabeln Delad nyckel .
Du kan också ändra variablerna för loggtypen och JSON-data.
PowerShell-exempel
# 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#-exempel
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 exempel
Anteckning
Om du använder Python 2 kan du behöva ändra raden:bytes_to_hash = bytes(string_to_hash, encoding="utf-8") Att 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-exempel
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;
}
}
Alternativ och överväganden
Även om API:et för datainsamlare bör omfatta de flesta av dina behov när du samlar in kostnadsfria data i Azure-loggar, kan du behöva en alternativ metod för att övervinna vissa av begränsningarna i API:et. Dina alternativ, inklusive viktiga överväganden, visas i följande tabell:
| Alternativ | Beskrivning | Passar bäst för |
|---|---|---|
| Anpassade händelser: Intern SDK-baserad inmatning i Application Insights | Application Insights, som vanligtvis instrumenteras via en SDK i ditt program, ger dig möjlighet att skicka anpassade data via anpassade händelser. |
|
| API för datainsamlare i Azure Monitor-loggar | API:et för datainsamlare i Azure Monitor-loggar är ett helt öppet sätt att mata in data. Alla data som är formaterade i ett JSON-objekt kan skickas hit. När den har skickats bearbetas den och görs tillgänglig i Övervakningsloggar för att korreleras med andra data i Övervakningsloggar eller mot andra Application Insights-data. Det är ganska enkelt att ladda upp data som filer till en Azure Blob Storage blob, där filerna bearbetas och sedan laddas upp till Log Analytics. En exempelimplementering finns i Skapa en datapipeline med API:et datainsamlare. |
|
| Azure-datautforskaren | Azure Data Explorer, som nu är allmänt tillgängligt för allmänheten, är den dataplattform som driver Application Insights Analytics och Azure Monitor-loggar. Genom att använda dataplattformen i dess råa form har du fullständig flexibilitet (men kräver hanteringskostnaderna) över klustret (Rollbaserad åtkomstkontroll i Kubernetes (RBAC), kvarhållningshastighet, schema och så vidare). Azure Data Explorer innehåller många inmatningsalternativ, inklusive CSV-, TSV- och JSON-filer. |
|
Nästa steg
Använd LOG Search-API :et för att hämta data från Log Analytics-arbetsytan.
Läs mer om hur du skapar en datapipeline med API:et för datainsamlare med hjälp av ett Logic Apps-arbetsflöde till Azure Monitor.