Codice di esempio per inviare dati a Monitoraggio di Azure usando l'API di inserimento dei log

Articolo
04/15/2024

Questo articolo fornisce codice di esempio usando l'API di inserimento 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 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 Log Analytics
Endpoint di raccolta dati (DCE) per ricevere i dati
Regola di raccolta dati (DCR) per indirizzare i dati alla tabella di destinazione
Applicazione Microsoft Entra con accesso al Registro Azure Container

Codice di esempio

Lo script seguente usa la libreria client di inserimento di Monitoraggio di Azure per .NET.

Installare la libreria client di inserimento di Monitoraggio di Azure e la libreria di identità di Azure. 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 di DCE e 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://logs-ingestion-rzmk.eastus2-1.ingest.monitor.azure.com");
var ruleId = "dcr-00000000000000000000000000000000";
var streamName = "Custom-MyTableRawData";

// Create credential and client
var credential = new DefaultAzureCredential();
LogsIngestionClient client = new(endpoint, credential);

DateTimeOffset currentTime = DateTimeOffset.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
{
    Response response = client.Upload(ruleId, streamName, RequestContent.Create(data));
}
catch (Exception ex)
{
    Console.WriteLine("Upload failed with Exception " + ex.Message);
}

// Logs can also be uploaded in a List
var entries = new List<Object>();
for (int i = 0; i < 10; i++)
{
    entries.Add(
        new {
            Time = recordingNow,
            Computer = "Computer" + i.ToString(),
            AdditionalContext = i
        }
    );
}

// Make the request
LogsUploadOptions options = new LogsUploadOptions();
bool isTriggered = false;
options.UploadFailed += Options_UploadFailed;
await client.UploadAsync(TestEnvironment.DCRImmutableId, TestEnvironment.StreamName, entries, options).ConfigureAwait(false);

Task Options_UploadFailed(LogsUploadFailedEventArgs e)
{
    isTriggered = true;
    Console.WriteLine(e.Exception);
    foreach (var log in e.FailedLogs)
    {
        Console.WriteLine(log);
    }
    return Task.CompletedTask;
}

Eseguire il codice e i dati devono arrivare nell'area di lavoro Log Analytics entro pochi minuti.

Il codice di esempio seguente usa il modulo client Log di inserimento di Monitoraggio di Azure per Go.

Usare go get per installare i log di inserimento 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 dal DefaultAzureCredential modulo Azure Identity.
- AZURE_TENANT_ID
- AZURE_CLIENT_ID
- AZURE_CLIENT_SECRET

Sostituire le variabili nel codice di esempio seguente con i valori di DCE e 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"
)

// data collection endpoint (DCE)
const endpoint = "https://logs-ingestion-rzmk.eastus2-1.ingest.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 e i dati devono arrivare nell'area di lavoro Log Analytics entro pochi minuti.

Il codice di esempio seguente usa la libreria client di inserimento di Monitoraggio di Azure per Java.

Includere il pacchetto di inserimento dei log e il azure-identity pacchetto dalla libreria di identità di Azure. La libreria di identità di Azure è necessaria per l'autenticazione usata in questo esempio.

Nota

Vedere i repository Maven per la libreria client di Microsoft Azure per identità e Microsoft Azure SDK per l'inserimento dati di Monitoraggio di Azure per le versioni più recenti.
```
<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 di DCE e 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://logs-ingestion-rzmk.eastus2-1.ingest.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 e i dati devono arrivare nell'area di lavoro Log Analytics entro pochi minuti.

Il codice di esempio seguente usa la libreria client di inserimento di Monitoraggio di Azure per JavaScript.

Usare npm per installare le librerie client di inserimento di Monitoraggio di Azure e 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 di DCE e 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://logs-ingestion-rzmk.eastus2-1.ingest.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 e i dati devono arrivare nell'area di lavoro 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, DCE e 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 = "00000000-0000-0000-00000000000000000" #Tenant ID the data collection endpoint resides in
$appId = " 000000000-0000-0000-00000000000000000" #Application ID created and granted permissions
$appSecret = "0000000000000000000000000000000000000000" #Secret created for the application

# information needed to send data to the DCR endpoint
$dceEndpoint = "https://logs-ingestion-rzmk.eastus2-1.ingest.monitor.azure.com" #the endpoint property of the Data Collection Endpoint object
$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 DCE.

$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 via the DCE.

$body = $staticData;
$headers = @{"Authorization"="Bearer $bearerToken";"Content-Type"="application/json"};
$uri = "$dceEndpoint/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 Unable to find type [System.Web.HttpUtility]. errore, eseguire l'ultima riga nella sezione 1 dello script per una correzione ed eseguirla. L'esecuzione di un commento come parte dello script non risolverà il problema. Il comando deve essere eseguito separatamente.

Eseguire lo script e verrà visualizzata una HTTP - 204 risposta. I dati devono arrivare nell'area di lavoro 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 di DCE e DCR. È anche possibile sostituire i dati di esempio nella sezione Passaggio 2 con i propri.

# information needed to send data to the DCR endpoint
dce_endpoint = "https://logs-ingestion-rzmk.eastus2-1.ingest.monitor.azure.com" # ingestion endpoint of the Data Collection Endpoint object
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=dce_endpoint, 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 e i dati devono arrivare nell'area di lavoro Log Analytics entro pochi minuti.

Risoluzione dei problemi

In questa sezione vengono descritte le diverse condizioni di errore che è possibile ricevere e come correggerle.

Lo script restituisce il codice di errore 403

Assicurarsi di disporre delle autorizzazioni corrette per l'applicazione nel Registro Azure Container. Potrebbe anche essere necessario attendere fino a 30 minuti per la propagazione delle autorizzazioni.

Lo script restituisce il codice di errore 413 o l'avviso timeoutExpired con il messaggio ReadyBody_Client Connessione ionAbort nella risposta

Il messaggio è troppo grande. La dimensione massima del messaggio è attualmente di 1 MB per ogni chiamata.

Lo script restituisce il codice di 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.

Lo script restituisce il codice di errore 503

Non viene visualizzato un errore, ma i dati non vengono visualizzati nell'area di lavoro

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.

Codice di esempio per inviare dati a Monitoraggio di Azure usando l'API di inserimento dei log

Codice di esempio

Risoluzione dei problemi

Lo script restituisce il codice di errore 403

Lo script restituisce il codice di errore 413 o l'avviso timeoutExpired con il messaggio ReadyBody_Client Connessione ionAbort nella risposta

Lo script restituisce il codice di errore 429

Lo script restituisce il codice di errore 503

Non viene visualizzato un errore, ma i dati non vengono visualizzati nell'area di lavoro

IntelliSense in Log Analytics non riconosce la nuova tabella

Passaggi successivi

Risorse aggiuntive