Questo articolo fornisce codice di esempio usando l'API di inserimento dei log. Per ogni esempio è necessario creare i componenti seguenti prima dell'esecuzione del codice. Vedere Esercitazione: Inviare dati a Monitoraggio di Azure usando l'API di inserimento dei log (modelli di Resource Manager) per una procedura dettagliata completa sulla creazione di questi componenti configurati per supportare ognuno di questi esempi.
- Tabella personalizzata in un'area di lavoro di Log Analytics
- Regola di raccolta dati (DCR) per indirizzare i dati alla tabella di destinazione
- Applicazione Microsoft Entra con accesso alla DCR
- Endpoint di raccolta dati (DCE) se si usa un collegamento privato. In caso contrario, usare l'endpoint dei log DCR.
Codice di esempio
Lo script seguente usa la libreria client per l'inserimento di Azure Monitor per .NET.
Installare la libreria client di Azure Monitor Ingestion e la libreria client di Azure Identity. La libreria di identità di Azure è necessaria per l'autenticazione usata in questo esempio.
dotnet add package Azure.Identity
dotnet add package Azure.Monitor.Ingestion
Creare le variabili di ambiente seguenti con i valori per l'applicazione Microsoft Entra. Questi valori vengono usati da DefaultAzureCredential nella libreria di identità di Azure.
AZURE_TENANT_ID
AZURE_CLIENT_ID
AZURE_CLIENT_SECRET
Sostituire le variabili nel codice di esempio seguente con i valori del tuo DCR. È anche possibile sostituire i dati di esempio con i propri.
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.Monitor.Ingestion;
// Initialize variables
var endpoint = new Uri("https://my-url.monitor.azure.com");
var ruleId = "dcr-00000000000000000000000000000000";
var streamName = "Custom-MyTableRawData";
// Create credential and client
var credential = new DefaultAzureCredential();
LogsIngestionClient client = new LogsIngestionClient(endpoint, credential);
DateTime currentTime = DateTime.UtcNow;
// Use BinaryData to serialize instances of an anonymous type into JSON
BinaryData data = BinaryData.FromObjectAsJson(
new[] {
new
{
Time = currentTime,
Computer = "Computer1",
AdditionalContext = new
{
InstanceName = "user1",
TimeZone = "Pacific Time",
Level = 4,
CounterName = "AppMetric1",
CounterValue = 15.3
}
},
new
{
Time = currentTime,
Computer = "Computer2",
AdditionalContext = new
{
InstanceName = "user2",
TimeZone = "Central Time",
Level = 3,
CounterName = "AppMetric1",
CounterValue = 23.5
}
},
}
);
// Upload logs
try
{
// ===== START: Use this block of code to upload compressed data
byte[] dataBytes = data.ToArray();
string contentEncoding = "gzip"; // Specify gzip if the content is already compressed
using (MemoryStream memoryStream = new MemoryStream())
{
using (GZipStream gzipStream = new GZipStream(memoryStream, CompressionMode.Compress))
{
gzipStream.Write(dataBytes, 0, dataBytes.Length);
}
byte[] gzipBytes = memoryStream.ToArray();
var response = await client.UploadAsync(ruleId, streamName, RequestContent.Create(gzipBytes), contentEncoding).ConfigureAwait(false);
if (response.IsError)
{
throw new Exception(response.ToString());
}
}
// ===== End: code block to upload compressed data
//** ===== START: Use this block of code to upload uncompressed data.
var response = await client.UploadAsync(ruleId, streamName, RequestContent.Create(data)).ConfigureAwait(false);
if (response.IsError)
{
throw new Exception(response.ToString());
}
//** ===== End: code block to upload uncompressed data.
}
catch (Exception ex)
{
Console.WriteLine("Upload failed with Exception: " + ex.Message);
}
- Eseguire il codice; i dati dovrebbero arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Il codice di esempio seguente usa il modulo client per i log di inserimento di Azure Monitor per Go.
Usare go get per installare i log di inserimento dati di Monitoraggio di Azure e i moduli client di Identità di Azure per Go. Il modulo Azure Identity è necessario per l'autenticazione usata in questo esempio.
go get github.com/Azure/azure-sdk-for-go/sdk/monitor/ingestion/azlogs
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
Creare le variabili di ambiente seguenti con i valori per l'applicazione Microsoft Entra. Questi valori vengono usati da DefaultAzureCredential nel modulo Azure Identity.
AZURE_TENANT_ID
AZURE_CLIENT_ID
AZURE_CLIENT_SECRET
Sostituire le variabili nel codice di esempio seguente con i valori del tuo DCR. È anche possibile sostituire i dati di esempio con i propri.
package main
import (
"context"
"encoding/json"
"strconv"
"time"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/monitor/ingestion/azlogs"
)
// logs ingestion URI
const endpoint = "https://my-url.monitor.azure.com"
// data collection rule (DCR) immutable ID
const ruleID = "dcr-00000000000000000000000000000000"
// stream name in the DCR that represents the destination table
const streamName = "Custom-MyTableRawData"
type Computer struct {
Time time.Time
Computer string
AdditionalContext string
}
func main() {
// creating the client using DefaultAzureCredential
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
//TODO: handle error
}
client, err := azlogs.NewClient(endpoint, cred, nil)
if err != nil {
//TODO: handle error
}
// generating logs
// logs should match the schema defined by the provided stream
var data []Computer
for i := 0; i < 10; i++ {
data = append(data, Computer{
Time: time.Now().UTC(),
Computer: "Computer" + strconv.Itoa(i),
AdditionalContext: "context",
})
}
// marshal data into []byte
logs, err := json.Marshal(data)
if err != nil {
panic(err)
}
// upload logs
_, err = client.Upload(context.TODO(), ruleID, streamName, logs, nil)
if err != nil {
//TODO: handle error
}
}
Eseguire il codice; i dati dovrebbero arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Il codice di esempio seguente usa la libreria client di Azure Monitor per l'inserimento in Java.
Includere il pacchetto di inserimento dei log e il pacchetto azure-identity dalla libreria di identità di Azure. La libreria di identità di Azure è necessaria per l'autenticazione usata in questo esempio.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-monitor-ingestion</artifactId>
<version>{get-latest-version}</version>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>{get-latest-version}</version>
</dependency>
Creare le variabili di ambiente seguenti con i valori per l'applicazione Microsoft Entra. Questi valori vengono usati da DefaultAzureCredential nella libreria di identità di Azure.
AZURE_TENANT_ID
AZURE_CLIENT_ID
AZURE_CLIENT_SECRET
Sostituire le variabili nel codice di esempio seguente con i valori del tuo DCR. È anche possibile sostituire i dati di esempio con i propri.
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.monitor.ingestion.models.LogsUploadException;
import java.time.OffsetDateTime;
import java.util.Arrays;
import java.util.List;
public class LogsUploadSample {
public static void main(String[] args) {
LogsIngestionClient client = new LogsIngestionClientBuilder()
.endpoint("https://my-url.monitor.azure.com")
.credential(new DefaultAzureCredentialBuilder().build())
.buildClient();
List<Object> dataList = Arrays.asList(
new Object() {
OffsetDateTime time = OffsetDateTime.now();
String computer = "Computer1";
Object additionalContext = new Object() {
String instanceName = "user4";
String timeZone = "Pacific Time";
int level = 4;
String counterName = "AppMetric1";
double counterValue = 15.3;
};
},
new Object() {
OffsetDateTime time = OffsetDateTime.now();
String computer = "Computer2";
Object additionalContext = new Object() {
String instanceName = "user2";
String timeZone = "Central Time";
int level = 3;
String counterName = "AppMetric2";
double counterValue = 43.5;
};
});
try {
client.upload("dcr-00000000000000000000000000000000", "Custom-MyTableRawData", dataList);
System.out.println("Logs uploaded successfully");
} catch (LogsUploadException exception) {
System.out.println("Failed to upload logs ");
exception.getLogsUploadErrors()
.forEach(httpError -> System.out.println(httpError.getMessage()));
}
}
}
Eseguire il codice; i dati dovrebbero arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Il codice di esempio seguente utilizza la libreria client di inserimento di Azure Monitor per JavaScript.
Usare npm per installare le librerie client di Ingestione di Monitoraggio di Azure e di Identità di Azure per JavaScript. La libreria di identità di Azure è necessaria per l'autenticazione usata in questo esempio.
npm install --save @azure/monitor-ingestion
npm install --save @azure/identity
Creare le variabili di ambiente seguenti con i valori per l'applicazione Microsoft Entra. Questi valori vengono usati da DefaultAzureCredential nella libreria di identità di Azure.
AZURE_TENANT_ID
AZURE_CLIENT_ID
AZURE_CLIENT_SECRET
Sostituire le variabili nel codice di esempio seguente con i valori del tuo DCR. È anche possibile sostituire i dati di esempio con i propri.
const { DefaultAzureCredential } = require("@azure/identity");
const { LogsIngestionClient, isAggregateLogsUploadError } = require("@azure/monitor-ingestion");
require("dotenv").config();
async function main() {
const logsIngestionEndpoint = "https://my-url.monitor.azure.com";
const ruleId = "dcr-00000000000000000000000000000000";
const streamName = "Custom-MyTableRawData";
const credential = new DefaultAzureCredential();
const client = new LogsIngestionClient(logsIngestionEndpoint, credential);
const logs = [
{
Time: "2021-12-08T23:51:14.1104269Z",
Computer: "Computer1",
AdditionalContext: {
"InstanceName": "user1",
"TimeZone": "Pacific Time",
"Level": 4,
"CounterName": "AppMetric2",
"CounterValue": 35.3
}
},
{
Time: "2021-12-08T23:51:14.1104269Z",
Computer: "Computer2",
AdditionalContext: {
"InstanceName": "user2",
"TimeZone": "Pacific Time",
"Level": 4,
"CounterName": "AppMetric2",
"CounterValue": 43.5
}
},
];
try{
await client.upload(ruleId, streamName, logs);
}
catch(e){
let aggregateErrors = isAggregateLogsUploadError(e) ? e.errors : [];
if (aggregateErrors.length > 0) {
console.log("Some logs have failed to complete ingestion");
for (const error of aggregateErrors) {
console.log(`Error - ${JSON.stringify(error.cause)}`);
console.log(`Log - ${JSON.stringify(error.failedLogs)}`);
}
} else {
console.log(e);
}
}
}
main().catch((err) => {
console.error("The sample encountered an error:", err);
process.exit(1);
});
Eseguire il codice; i dati dovrebbero arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Il codice di PowerShell seguente invia i dati all'endpoint usando le nozioni fondamentali su REST HTTP.
Nota
Questo esempio richiede PowerShell v7.0 o versione successiva.
Eseguire il comando di PowerShell di esempio seguente, che aggiunge un assembly necessario per lo script.
Add-Type -AssemblyName System.Web
Sostituire i parametri nella sezione Passaggio 0 con i valori dell'applicazione e della DCR. È anche possibile sostituire i dati di esempio nella sezione Passaggio 2 con i propri.
### Step 0: Set variables required for the rest of the script.
# information needed to authenticate to AAD and obtain a bearer token
$tenantId = "aaaabbbb-0000-cccc-1111-dddd2222eeee" #Tenant ID the data collection endpoint resides in
$appId = "00001111-aaaa-2222-bbbb-3333cccc4444" #Application ID created and granted permissions
$appSecret = "Aa1Bb~2Cc3.-Dd4Ee5Ff6Gg7Hh8Ii9_Jj0Kk1Ll2" #Secret created for the application
# information needed to send data to the DCR endpoint
$endpoint_uri = "https://my-url.monitor.azure.com" #Logs ingestion URI for the DCR
$dcrImmutableId = "dcr-00000000000000000000000000000000" #the immutableId property of the DCR object
$streamName = "Custom-MyTableRawData" #name of the stream in the DCR that represents the destination table
### Step 1: Obtain a bearer token used later to authenticate against the DCR.
$scope= [System.Web.HttpUtility]::UrlEncode("https://monitor.azure.com//.default")
$body = "client_id=$appId&scope=$scope&client_secret=$appSecret&grant_type=client_credentials";
$headers = @{"Content-Type"="application/x-www-form-urlencoded"};
$uri = "https://login.microsoftonline.com/$tenantId/oauth2/v2.0/token"
$bearerToken = (Invoke-RestMethod -Uri $uri -Method "Post" -Body $body -Headers $headers).access_token
### Step 2: Create some sample data.
$currentTime = Get-Date ([datetime]::UtcNow) -Format O
$staticData = @"
[
{
"Time": "$currentTime",
"Computer": "Computer1",
"AdditionalContext": {
"InstanceName": "user1",
"TimeZone": "Pacific Time",
"Level": 4,
"CounterName": "AppMetric1",
"CounterValue": 15.3
}
},
{
"Time": "$currentTime",
"Computer": "Computer2",
"AdditionalContext": {
"InstanceName": "user2",
"TimeZone": "Central Time",
"Level": 3,
"CounterName": "AppMetric1",
"CounterValue": 23.5
}
}
]
"@;
### Step 3: Send the data to the Log Analytics workspace.
$body = $staticData;
$headers = @{"Authorization"="Bearer $bearerToken";"Content-Type"="application/json"};
$uri = "$endpoint_uri/dataCollectionRules/$dcrImmutableId/streams/$($streamName)?api-version=2023-01-01"
$uploadResponse = Invoke-RestMethod -Uri $uri -Method "Post" -Body $body -Headers $headers
Nota
Se viene visualizzato un errore Unable to find type [System.Web.HttpUtility]., eseguire l'ultima riga nella sezione 1 dello script per una correzione ed eseguirla. L'esecuzione senza commenti come parte dello script non risolverà il problema. Il comando deve essere eseguito separatamente.
Eseguire lo script e verrà visualizzata una risposta HTTP - 204. I dati devono arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Il codice di esempio seguente usa la libreria client di inserimento di Monitoraggio di Azure per Python.
Usare pip per installare le librerie client di inserimento di Monitoraggio di Azure e Identità di Azure per Python. La libreria di identità di Azure è necessaria per l'autenticazione usata in questo esempio.
pip install azure-monitor-ingestion
pip install azure-identity
Creare le variabili di ambiente seguenti con i valori per l'applicazione Microsoft Entra. Questi valori vengono usati da DefaultAzureCredential nella libreria di identità di Azure.
AZURE_TENANT_ID
AZURE_CLIENT_ID
AZURE_CLIENT_SECRET
Sostituire le variabili nel codice di esempio seguente con i valori del tuo DCR. È anche possibile sostituire i dati di esempio nella sezione Passaggio 2 con i propri.
# information needed to send data to the DCR endpoint
endpoint_uri = "https://my-url.monitor.azure.com" # logs ingestion endpoint of the DCR
dcr_immutableid = "dcr-00000000000000000000000000000000" # immutableId property of the Data Collection Rule
stream_name = "Custom-MyTableRawData" #name of the stream in the DCR that represents the destination table
# Import required modules
import os
from azure.identity import DefaultAzureCredential
from azure.monitor.ingestion import LogsIngestionClient
from azure.core.exceptions import HttpResponseError
credential = DefaultAzureCredential()
client = LogsIngestionClient(endpoint=endpoint_uri, credential=credential, logging_enable=True)
body = [
{
"Time": "2023-03-12T15:04:48.423211Z",
"Computer": "Computer1",
"AdditionalContext": {
"InstanceName": "user1",
"TimeZone": "Pacific Time",
"Level": 4,
"CounterName": "AppMetric2",
"CounterValue": 35.3
}
},
{
"Time": "2023-03-12T15:04:48.794972Z",
"Computer": "Computer2",
"AdditionalContext": {
"InstanceName": "user2",
"TimeZone": "Central Time",
"Level": 3,
"CounterName": "AppMetric2",
"CounterValue": 43.5
}
}
]
try:
client.upload(rule_id=dcr_immutableid, stream_name=stream_name, logs=body)
except HttpResponseError as e:
print(f"Upload failed: {e}")
Eseguire il codice; i dati dovrebbero arrivare nell'area di lavoro di Log Analytics entro pochi minuti.
Risoluzione dei problemi
In questa sezione vengono descritte le diverse condizioni di errore che è possibile ricevere e come correggerle.
| Errore |
Descrizione |
| Codice errore 403 |
Assicurati di avere le autorizzazioni corrette per la tua applicazione al DCR. Potrebbe anche essere necessario attendere fino a 30 minuti per la propagazione delle autorizzazioni. |
Codice di errore 413 o avviso di TimeoutExpired con il messaggio ReadyBody_ClientConnectionAbort nella risposta |
Il messaggio è troppo grande. La dimensione massima del messaggio è attualmente di 1 MB per ogni chiamata. |
Codice di errore RecordsTimeRangeIsMoreThan30Minutes |
Si tratta di una limitazione nota che viene rimossa. Questa restrizione non si applica ai log ausiliari che usano trasformazioni. |
| Codice errore 429 |
Sono stati superati i limiti delle API. I limiti sono attualmente impostati su 500 MB di dati al minuto per dati compressi e non compressi e 300.000 richieste al minuto. Riprovare dopo la durata elencata nell'intestazione Retry-After nella risposta. |
| Nessun dato |
L'inserimento dei dati potrebbe richiedere del tempo, in particolare la prima volta che i dati vengono inviati a una determinata tabella. Non dovrebbero essere necessari più di 15 minuti. |
| IntelliSense in Log Analytics non riconosce la nuova tabella. |
L'aggiornamento della cache che gestisce IntelliSense potrebbe richiedere fino a 24 ore. |
Passaggi successivi