Scenario: Elaborazione batch automatica autonoma dell'Agente

Implementare l'elaborazione batch autonoma usando le identità dell'agente per eseguire operazioni senza contesto utente. Questo scenario consente l'elaborazione batch di volumi di dati di grandi dimensioni, attività pianificate tramite processi cron, operazioni in background esterne alle sessioni utente e flussi di lavoro protetti da servizio a sistema. Questa guida illustra come configurare Microsoft Entra SDK per l'ID agente e implementare modelli comuni come processi pianificati ed elaborazione basata su coda.

Prerequisiti

  • Un account Azure con una sottoscrizione attiva. Creare un account gratuito.
  • Microsoft Entra SDK per AgentID distribuito nel tuo ambiente con il supporto per l'identità dell'agente abilitato. Per istruzioni sull'installazione, vedere Guida all'installazione .
  • Applicazione registrata in Microsoft Entra ID - Registrare una nuova app nel Centro di amministrazione di Microsoft Entra per il servizio batch. Per informazioni dettagliate, vedere Registrare un'applicazione . Registrazione:
    • ID applicazione (cliente)
    • ID della directory (cliente)
    • Creare un segreto client o un certificato per l'autenticazione
    • Configurare le autorizzazioni dell'applicazione per le API downstream a cui accederà il processo batch (ad esempio, Microsoft Graph autorizzazioni)
  • Le autorizzazioni appropriate in Microsoft Entra ID: l'account deve disporre delle autorizzazioni per registrare le applicazioni, configurare le identità degli agenti e concedere le autorizzazioni dell'applicazione.
  • Access alle API downstream - Le API di destinazione (ad esempio Microsoft Graph) devono essere accessibili e configurate con gli ambiti necessari per le operazioni batch.

Configurazione dell'identità dell'agente

Per informazioni dettagliate sulla creazione di identità dell'agente e sulla configurazione delle credenziali di identità federate, vedere la documentazione di Microsoft agent Identity Platform.

Requisiti di configurazione principali

Quando si configura un'identità agente per l'elaborazione batch:

  1. Credenziali di identità federate: configurare la federazione dell'identità del carico di lavoro per consentire all'applicazione di ottenere token senza archiviare segreti
  2. Application Permissions: concedere all'identità dell'agente solo le autorizzazioni Microsoft API Graph (o altre autorizzazioni API downstream) richieste dall'operazione batch
  3. variabili di Environment: impostare ENTRA_SDK_URL in modo che punti all'istanza di SDK di Microsoft Entra in esecuzione per l'ID agente e archiviare l'agente CLIENT_ID da usare nel codice di elaborazione batch
  4. Scope del Token: assicurarsi che l'SDK di Microsoft Entra per l'ID dell'agente sia configurato per richiedere token nel contesto dell'entità del servizio, non per conto di un utente

Implementation

I frammenti di codice seguenti illustrano come implementare l'elaborazione batch autonoma con le identità dell'agente. Il principio chiave consiste nel passare l'identità dell'agente all'SDK di Microsoft Entra per l'ID agente e richiedere un token dell'applicazione anziché un token delegato dall'utente.

TypeScript

Richiedere un token dell'applicazione usando l'identità dell'agente per elaborare le operazioni batch:

async function processBatchWithAgent(
  incomingToken: string,
  agentIdentity: string
) {
  const sdkUrl = process.env.ENTRA_SDK_URL!;
  
  // Get users list using agent identity (autonomous)
  const response = await fetch(
    `${sdkUrl}/DownstreamApi/Graph?` +
    `AgentIdentity=${agentIdentity}&` +
    `optionsOverride.RelativePath=users&` +
    `optionsOverride.RequestAppToken=true`,
    {
      headers: {
        'Authorization': incomingToken
      }
    }
  );
  
  const result = await response.json();
  const users = JSON.parse(result.content);
  
  // Process each user
  for (const user of users.value) {
    await processUser(user);
  }
}

async function scheduledReportGeneration() {
  const agentIdentity = process.env.AGENT_CLIENT_ID!;
  const token = await getSystemToken();
  
  // Generate reports for all departments
  const departments = await getDepartments(token, agentIdentity);
  
  for (const dept of departments) {
    await generateDepartmentReport(token, agentIdentity, dept);
  }
}

Python

Ecco l'implementazione equivalente in Python usando la libreria delle richieste:

import requests
import os
import json

def process_batch_with_agent(incoming_token: str, agent_identity: str):
    """Process batch using autonomous agent."""
    sdk_url = os.getenv('ENTRA_SDK_URL', 'http://localhost:5000')
    
    # Get users using agent identity
    response = requests.get(
        f"{sdk_url}/DownstreamApi/Graph",
        params={
            'AgentIdentity': agent_identity,
            'optionsOverride.RelativePath': 'users',
            'optionsOverride.RequestAppToken': 'true'
        },
        headers={'Authorization': incoming_token}
    )
    
    result = response.json()
    users = json.loads(result['content'])
    
    # Process each user
    for user in users['value']:
        process_user(user)

Modelli di elaborazione batch

Diversi scenari richiedono approcci diversi per l'elaborazione batch. I frammenti di codice seguenti forniscono modelli per le implementazioni più comuni che sfruttano le identità dell'agente.

Processo pianificato

Usare i processi pianificati quando è necessario eseguire operazioni batch in momenti specifici:

// Cron-based batch processor
import cron from 'node-cron';

// Run every day at 2 AM
cron.schedule('0 2 * * *', async () => {
  console.log('Starting nightly batch process');
  
  try {
    await runAutonomousBatch(
      process.env.AGENT_CLIENT_ID!
    );
    console.log('Batch completed successfully');
  } catch (error) {
    console.error('Batch failed:', error);
  }
});

Elaborazione basata su coda

Usare l'elaborazione basata su coda quando gli elementi batch arrivano in modo asincrono o imprevedibile:

// Process messages from queue
async function processQueueMessages(queueClient, agentIdentity: string) {
  while (true) {
    const messages = await queueClient.receiveMessages(10);
    
    for (const message of messages) {
      try {
        await processMessage(message, agentIdentity);
        await queueClient.deleteMessage(message);
      } catch (error) {
        console.error('Message processing failed:', error);
      }
    }
    
    await sleep(5000);
  }
}

Procedure consigliate

  1. Usare le autorizzazioni dell'applicazione: concedere solo le autorizzazioni dell'applicazione necessarie per l'operazione batch, seguendo il principio dei privilegi minimi
  2. Implementare la logica di ripetizione dei tentativi: gestire gli errori temporanei con backoff esponenziale per migliorare l'affidabilità
  3. Monitorare lo stato di avanzamento: tenere traccia dello stato del processo batch e delle metriche chiave del log per abilitare la risoluzione dei problemi e l'analisi delle prestazioni
  4. Ambito limite: richiedere solo le autorizzazioni necessarie per ogni operazione
  5. Operazioni di controllo: registrare tutte le azioni dell'agente con informazioni dettagliate su cosa è stato elaborato e da quale agente
  6. Gestire la limitazione: Rispettare i limiti di frequenza dell'API e implementare strategie di backoff appropriate

Contenuti correlati

  • Last updated on