Inviare i dati di log a Monitoraggio di Azure usando l'API agente di raccolta dati HTTP (anteprima)

Questo articolo illustra come usare l'API di raccolta dati HTTP per inviare dati di log a Monitoraggio di Azure da un client dell'API REST. Descrive come formattare i dati raccolti dallo script o dall'applicazione, includerlo in una richiesta e avere tale richiesta autorizzata da Monitoraggio di Azure. Vengono forniti esempi per Azure PowerShell, C#e Python.

Nota

L'API di raccolta dati HTTP di Monitoraggio di Azure è in anteprima pubblica.

Concetti

È possibile usare l'API di raccolta dati HTTP per inviare dati di log a un'area di lavoro Log Analytics in Monitoraggio di Azure da qualsiasi client in grado di chiamare un'API REST. Il client potrebbe essere un runbook in Automazione di Azure che raccoglie i dati di gestione da Azure o da un altro cloud oppure potrebbe essere un sistema di gestione alternativo che usa Monitoraggio di Azure per consolidare e analizzare i dati di log.

Tutti i dati nell'area di lavoro Log Analytics vengono archiviati come record con un tipo specifico. Formattare i dati da inviare all'API agente di raccolta dati HTTP come più record in Notazione oggetti JavaScript (JSON). Quando si inviano i dati, nel repository viene creato un record singolo per ogni record presente nel payload della richiesta.

Screenshot illustrating the HTTP Data Collector overview.

Creare una richiesta

Per usare l'API agente di raccolta dati HTTP, si crea una richiesta POST che include i dati da inviare in JSON. Le tre tabelle successive indicano gli attributi necessari per ogni richiesta. Ogni attributo viene descritto con maggiori dettagli più avanti nell'articolo.

URI richiesta

Attributo Proprietà
Metodo POST
URI https://<IdCliente>.ods.opinsights.azure.com/api/logs?api-version=2016-04-01
Tipo di contenuto application/json

Parametri URI della richiesta

Parametro Descrizione
CustomerID Identificatore univoco per l'area di lavoro Log Analytics.
Risorsa Nome della risorsa API: /api/logs.
Versione API Versione dell'API da usare con questa richiesta. Attualmente, la versione è 2016-04-01.

Intestazioni della richiesta

Intestazione Descrizione
Autorizzazione Firma di autorizzazione. Più avanti nell'articolo sono disponibili informazioni sulla creazione di un'intestazione HMAC-SHA256.
Log-Type Specificare il tipo di record dei dati inviati. Può contenere solo lettere, numeri e caratteri di sottolineatura (_) e non può superare 100 caratteri.
x-ms-date Data di elaborazione della richiesta in formato RFC 7234.
x-ms-AzureResourceId ID risorsa della risorsa di Azure a cui devono essere associati i dati. Popola la proprietà _ResourceId e consente di includere i dati nelle query di contesto delle risorse . Se questo campo non è specificato, i dati non verranno inclusi nelle query di contesto delle risorse.
time-generated-field Nome di un campo nei dati che contiene il timestamp dell'elemento di dati. Se si specifica un campo, il relativo contenuto viene usato per TimeGenerated. Se non si specifica questo campo, il valore predefinito per TimeGenerated è il momento in cui viene inserito il messaggio. Il contenuto del campo del messaggio deve seguire il formato ISO 8601 AAAA-MM-GGThh:mm:ssZ.

Autorizzazione

Qualsiasi richiesta inviata all'API di raccolta dati HTTP di Monitoraggio di Azure deve includere l'intestazione dell'autorizzazione. Per autenticare una richiesta, firmare la richiesta con la chiave primaria o secondaria per l'area di lavoro che effettua la richiesta. Passare quindi la firma come parte della richiesta.

Il formato dell'intestazione dell'autorizzazione è il seguente:

Authorization: SharedKey <WorkspaceID>:<Signature>

WorkspaceID è l'identificatore univoco per l'area di lavoro Log Analytics. La firma è un codice HMAC (Hash-based Message Authentication Code) costruito dalla richiesta e quindi calcolato usando l'algoritmo SHA256. Viene quindi codificato con la codifica Base64.

Usare questo formato per codificare la stringa di firma SharedKey:

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

Di seguito è riportato un esempio di stringa della firma:

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

La stringa della firma deve essere codificata usando l'algoritmo HMAC-SHA256 sulla stringa con codifica UTF-8. Il risultato deve essere quindi codificato in Base64. Usare il formato seguente:

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

Gli esempi nelle sezioni successive indicano il codice di esempio per creare l'intestazione dell'autorizzazione.

Testo della richiesta

Il corpo del messaggio deve essere in formato JSON. Deve includere uno o più record con il nome della proprietà e le coppie valore nel formato seguente. Il nome della proprietà può contenere solo lettere, numeri e carattere di sottolineatura (_).

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

È possibile creare batch di più record in una singola richiesta usando il formato seguente. Tutti i record devono essere dello stesso tipo.

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

Proprietà e tipo di record

Quando si inviano dati con l'API di raccolta dati HTTP di Monitoraggio di Azure si definisce un tipo di record personalizzato. È attualmente possibile scrivere dati nei tipi di record esistenti creati da altri tipi di dati e soluzioni. Monitoraggio di Azure legge i dati in ingresso e quindi crea le proprietà che corrispondono ai tipi di dati dei valori immessi.

Ogni richiesta all'API di raccolta dati deve includere un'intestazione Log-Type con il nome del tipo di record. Il suffisso _CL viene aggiunto automaticamente al nome immesso per distinguerlo da altri tipi di log come log personalizzato. Se ad esempio si immette il nome MyNewRecordType, Monitoraggio di Azure crea un record di tipo MyNewRecordType_CL. È così possibile evitare conflitti tra i nomi dei tipi creati dall'utente e i nomi forniti nelle soluzioni Microsoft correnti o future.

Per identificare il tipo di dati di una proprietà, Monitoraggio di Azure aggiunge un suffisso al nome della proprietà. Se una proprietà contiene un valore Null, la proprietà non è inclusa in tale record. Questa tabella elenca il tipo di dati proprietà e il suffisso corrispondente:

Tipo di dati proprietà Suffisso
string _s
Boolean _b
Double _d
Data/ora _t
GUID (archiviato come stringa) _g

Nota

I valori stringa che sembrano essere GUID vengono assegnati al suffisso _g e formattati come GUID, anche se il valore in ingresso non include trattini. Ad esempio, sia "8145d822-13a7-44ad-859c-36f31a84f6dd" e "8145d82213a7444ad859c36f31a84f6dd" vengono archiviati come "8145d822-13a7-44ad-859c-36f31a84f6ddd". Le uniche differenze tra questa e un'altra stringa sono le _g nel nome e l'inserimento di trattini se non vengono forniti nell'input.

Il tipo di dati usato da Monitoraggio di Azure per ogni proprietà dipende dall'eventuale esistenza di un tipo di record per il nuovo record.

  • Se il tipo di record non esiste, Monitoraggio di Azure crea uno nuovo usando l'inferenza del tipo JSON per determinare il tipo di dati per ogni proprietà per il nuovo record.
  • Se il tipo di record esiste, Monitoraggio di Azure prova a creare un nuovo record in base alle proprietà esistenti. Se il tipo di dati di una proprietà nel nuovo record non corrisponde e non può essere convertito nel tipo esistente, oppure se il record include una proprietà che non esiste, Monitoraggio di Azure crea una nuova proprietà con il suffisso pertinente.

Ad esempio, la voce di invio seguente creerebbe un record con tre proprietà, number_d, boolean_b e string_s:

Screenshot of sample record 1.

Se si desidera inviare questa voce successiva, con tutti i valori formattati come stringhe, le proprietà non cambiano. È possibile convertire i valori in tipi di dati esistenti.

Screenshot of sample record 2.

Tuttavia, se si effettua questo invio successivo, Monitoraggio di Azure creerebbe le nuove proprietà boolean_d e string_d. Non è possibile convertire questi valori.

Screenshot of sample record 3.

Se si invia quindi la voce seguente, prima della creazione del tipo di record, Monitoraggio di Azure creerebbe un record con tre proprietà, number_s, boolean_s e string_s. In questa voce, ognuno dei valori iniziali viene formattato come stringa:

Screenshot of sample record 4.

Proprietà riservate

Le proprietà seguenti sono riservate e non devono essere usate in un tipo di record personalizzato. Verrà visualizzato un errore se il payload include uno di questi nomi di proprietà:

  • tenant
  • TimeGenerated
  • RawData

Limiti dei dati

I dati inviati all'API raccolta dati di Monitoraggio di Azure sono soggetti a determinati vincoli:

  • Limite di 30 MB per post nell'API per la raccolta dei dati di Monitoraggio di Azure. Questo limite riguarda le dimensioni di ogni messaggio. Se i dati di un singolo post superano i 30 MB, è necessario suddividere i dati in blocchi di dimensioni inferiori e inviarli simultaneamente.
  • Massimo 32 KB per i valori dei campi. Se il valore di un campo è superiore a 32 KB, i dati verranno troncati.
  • Valore massimo consigliato di 50 campi per un determinato tipo. Si tratta di un limite pratico dal punto di vista dell'usabilità e dell'esperienza di ricerca.
  • Le tabelle nelle aree di lavoro Log Analytics supportano solo fino a 500 colonne (denominate campi in questo articolo).
  • Massimo 50 caratteri per i nomi di colonna.

Codici restituiti

Il codice di stato HTTP 200 indica che è stata ricevuta la richiesta per l'elaborazione. Ciò indica che l'operazione è stata completata correttamente.

Il set completo di codici di stato che il servizio potrebbe restituire è elencato nella tabella seguente:

Codice Stato Codice di errore Descrizione
200 OK La richiesta è stata accettata.
400 Richiesta non valida InactiveCustomer L'area di lavoro è stata chiusa.
400 Richiesta non valida InvalidApiVersion La versione dell'API specificata non è stata riconosciuta dal servizio.
400 Richiesta non valida InvalidCustomerId L'ID dell'area di lavoro specificato non è valido.
400 Richiesta non valida InvalidDataFormat È stato inviato un JSON non valido. Il corpo della risposta può contenere altre informazioni sulla risoluzione dell'errore.
400 Richiesta non valida InvalidLogType Il tipo di log specificato contiene caratteri speciali o numeri.
400 Richiesta non valida MissingApiVersion La versione API non è stata specificata.
400 Richiesta non valida MissingContentType Il tipo di contenuto non è stato specificato.
400 Richiesta non valida MissingLogType Il tipo di log dei valori non è stato specificato.
400 Richiesta non valida UnsupportedContentType Il tipo di contenuto non è stato impostato su application/json.
403 Accesso negato InvalidAuthorization Il servizio non è riuscito ad autenticare la richiesta. Verificare che l'ID dell'area di lavoro e la chiave di connessione siano validi.
404 Non trovato L'URL specificato non è corretto o la richiesta è troppo grande.
429 Troppe richieste Il servizio sta ricevendo un elevato volume di dati dall'account. Si prega di ripetere la richiesta più tardi.
500 Internal Server Error UnspecifiedError Errore interno del servizio. Si prega di ripetere la richiesta.
503 Servizio non disponibile ServiceUnavailable Il servizio non è attualmente disponibile per la ricezione delle richieste. Si prega di ripetere la richiesta.

Eseguire query sui dati

Per eseguire query sui dati inviati dall'API dell'agente di raccolta dati HTTP di Monitoraggio di Azure, cercare i record il cui tipo è uguale al valore LogType specificato e aggiunto con _CL. Ad esempio, se si usa MyCustomLog, verranno restituiti tutti i record con MyCustomLog_CL.

Richieste di esempio

Nelle sezioni successive sono disponibili esempi che illustrano come inviare dati all'API dell'agente di raccolta dati HTTP di Monitoraggio di Azure usando vari linguaggi di programmazione.

Per ogni esempio, impostare le variabili per l'intestazione dell'autorizzazione eseguendo le operazioni seguenti:

  1. Nel portale di Azure individuare l'area di lavoro Log Analytics.
  2. Selezionare Gestione agenti.
  3. A destra dell'ID area di lavoro selezionare l'icona Copia e quindi incollare l'ID come valore della variabile ID cliente .
  4. A destra della chiave primaria selezionare l'icona Copia e quindi incollare l'ID come valore della variabile Chiave condivisa .

In alternativa è possibile modificare le variabili per il tipo di log e i dati JSON.

Esempio 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  

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

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

Esempio Python

Nota

Se si usa Python 2, potrebbe essere necessario modificare la riga:Da bytes_to_hash = bytes(string_to_hash, encoding="utf-8") a 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)

Esempio 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;
  }

}


Alternative e considerazioni

Anche se l'API dell'agente di raccolta dati deve coprire la maggior parte delle proprie esigenze durante la raccolta di dati in formato libero nei log di Azure, potrebbe essere necessario un approccio alternativo per superare alcune delle limitazioni dell'API. Le opzioni, incluse le considerazioni principali, sono elencate nella tabella seguente:

Alternativa Descrizione Ideale per
Eventi personalizzati: inserimento basato su SDK nativo in Application Insights L'applicazione Insights, in genere instrumentata tramite un SDK all'interno dell'applicazione, consente di inviare dati personalizzati tramite eventi personalizzati.
  • Dati generati all'interno dell'applicazione, ma non prelevati dall'SDK tramite uno dei tipi di dati predefiniti (richieste, dipendenze, eccezioni e così via).
  • I dati più spesso correlati ad altri dati dell'applicazione in Application Insights.
API dell'agente di raccolta dati nei log di Monitoraggio di Azure L'API dell'agente di raccolta dati nei log di Monitoraggio di Azure è un modo completamente aperto per inserire i dati. Tutti i dati formattati in un oggetto JSON possono essere inviati qui. Dopo l'invio, vengono elaborati e resi disponibili in Monitor Logs (Log di monitoraggio) per essere correlati ad altri dati in Monitor Logs (Log di monitoraggio) o ad altri dati di application Insights.

È abbastanza facile caricare i dati come file in un BLOB di Archiviazione BLOB di Azure, in cui i file verranno elaborati e quindi caricati in Log Analytics. Per un'implementazione di esempio, vedere Creare una pipeline di dati con l'API dell'agente di raccolta dati.
  • Dati che non vengono necessariamente generati all'interno di un'applicazione instrumentata all'interno di Application Insights.
    Gli esempi includono tabelle di ricerca e fatti, dati di riferimento, statistiche preaggregate e così via.
  • Dati a cui verrà fatto riferimento incrociato su altri dati di Monitoraggio di Azure (Application Insights, altri tipi di dati dei log di monitoraggio, Defender for Cloud, informazioni dettagliate sui contenitori e macchine virtuali e così via).
Esplora dati di Azure Azure Esplora dati, ora disponibile a livello generale per il pubblico, è la piattaforma dati che supporta Application Insights Analytics e i log di Monitoraggio di Azure. Usando la piattaforma dati in formato non elaborato, è disponibile una flessibilità completa (ma richiede il sovraccarico della gestione) nel cluster (controllo degli accessi in base al ruolo di Kubernetes), frequenza di conservazione, schema e così via. Azure Esplora dati offre molte opzioni di inserimento, tra cui file CSV, TSV e JSON.
  • Dati che non verranno correlati ad altri dati in Application Insights o Monitor Logs.
  • Dati che richiedono funzionalità avanzate di inserimento o elaborazione che non sono attualmente disponibili nei log di Monitoraggio di Azure.

Passaggi successivi