0Pricing
Azure Fundamentals · Lezione

Event Grid e architettura event-driven

Instradi gli eventi dai servizi Azure e dai publisher personalizzati usando Event Grid, distribuiscili tra più subscriber e confronti Event Grid con Event Hubs e Service Bus.

Event Grid e architettura event-driven è una lezione Azure Fundamentals gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Azure Fundamentals, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Azure Fundamentals include 4 lezioni in totale.

Che cos'è l'architettura basata sugli eventi

In un'architettura basata sugli eventi, i componenti comunicano pubblicando e sottoscrivendo eventi invece di chiamarsi direttamente tra loro. Un componente (produttore) emette un evento quando si verifica qualcosa di rilevante: viene caricato un file, viene effettuato un ordine o un dispositivo invia una misurazione. Gli altri componenti (sottoscrittori) reagiscono agli eventi di loro interesse in modo indipendente e asincrono. In questo modo i produttori vengono disaccoppiati dai consumatori, migliorando scalabilità, resilienza e manutenibilità.

Che cos'è Azure Event Grid

Azure Event Grid è un servizio di routing degli eventi completamente gestito che distribuisce gli eventi dalle origini (publisher) ai gestori (subscriber) utilizzando un modello push. Event Grid è progettato per eventi reattivi e discreti: qualcosa è cambiato ed è necessario reagire immediatamente. Garantisce una distribuzione almeno una volta con nuovi tentativi automatici, supporta i filtri affinché i sottoscrittori ricevano solo gli eventi pertinenti e può instradare gli eventi verso Azure Functions, Logic Apps, webhook, Event Hubs e code di Service Bus.

Argomenti di Event Grid e sottoscrizioni agli eventi

I publisher inviano gli eventi a un argomento di Event Grid. I subscriber creano sottoscrizioni agli eventi su un argomento, specificando un endpoint e, facoltativamente, regole di filtro. Un singolo argomento può avere più sottoscrizioni: ogni sottoscrizione riceve una copia indipendente degli eventi corrispondenti. Servizi Azure come Blob Storage, Resource Manager, Service Bus e Azure Container Registry sono origini di eventi integrate con argomenti di sistema che non richiedono configurazioni aggiuntive.

# Create a custom Event Grid topic
az eventgrid topic create \
  --name MyEventTopic \
  --resource-group MyRG \
  --location eastus

# Create a subscription routing to an Azure Function
az eventgrid event-subscription create \
  --name myFunctionSub \
  --source-resource-id '/subscriptions/.../providers/Microsoft.EventGrid/topics/MyEventTopic' \
  --endpoint '/subscriptions/.../providers/Microsoft.Web/sites/myFunctionApp/functions/EventHandler'

Schema degli eventi

Gli eventi pubblicati in Event Grid seguono uno schema JSON standard con campi obbligatori: id (identificatore univoco), eventType (ad esempio Microsoft.Storage.BlobCreated), subject (percorso della risorsa dell'evento), eventTime (timestamp ISO 8601), dataVersion e data (payload specifico dell'evento). Event Grid supporta anche lo schema CloudEvents (standard CNCF) per l'interoperabilità con altre piattaforme di eventi.

// Event Grid event payload (Event Grid schema)
[
  {
    'id': 'b781910b-3000-4f19-a4c2-b6b9c4ca7a12',
    'eventType': 'Microsoft.Storage.BlobCreated',
    'subject': '/blobServices/default/containers/uploads/blobs/photo.jpg',
    'eventTime': '2025-01-15T12:30:00.000Z',
    'data': {
      'api': 'PutBlockList',
      'url': 'https://mystorageacct.blob.core.windows.net/uploads/photo.jpg',
      'contentType': 'image/jpeg',
      'contentLength': 524288
    },
    'dataVersion': '',
    'metadataVersion': '1'
  }
]

Filtraggio degli eventi

Le sottoscrizioni agli eventi supportano il filtraggio per ridurre il rumore sul lato del sottoscrittore. È possibile filtrare per tipo di evento (ricevere solo BlobCreated, non BlobDeleted), per prefisso o suffisso dell'oggetto (solo i blob in un contenitore specifico) oppure applicare filtri avanzati a qualsiasi campo nei dati dell'evento usando operatori come StringContains, NumberGreaterThan e BoolEquals. Il filtraggio avviene lato server, quindi i sottoscrittori ricevono solo gli eventi che soddisfano i relativi criteri.

# Subscribe to BlobCreated events for .jpg files only
az eventgrid event-subscription create \
  --name jpgImageSub \
  --source-resource-id '/subscriptions/.../storageAccounts/mystorageaccount' \
  --endpoint 'https://myfunction.azurewebsites.net/api/ProcessImage' \
  --included-event-types 'Microsoft.Storage.BlobCreated' \
  --subject-ends-with '.jpg'

Event Grid, Event Hubs e Service Bus a confronto

Tre servizi Azure gestiscono eventi e messaggi: scelga in base allo scenario. Event Grid è destinato al routing reattivo degli eventi (volumi ridotti, eventi discreti e reattivi, ad esempio una notifica di modifica di una risorsa). Event Hubs è destinato allo streaming di eventi ad alta velocità (milioni di eventi al secondo, telemetria, pipeline di big data). Service Bus è destinato alla messaggistica enterprise con ordinamento, rilevamento dei duplicati, messaggi non recapitabili e transazioni (elaborazione degli ordini, transazioni finanziarie).

// Decision guide:
// Event Grid  — 'Something happened, react to it'
//               Azure resource events, webhooks, low-latency fan-out
//               Price: per event (cheap for low volume)

// Event Hubs  — 'Capture a firehose of streaming data'
//               IoT telemetry, log aggregation, real-time analytics
//               Price: per throughput unit + capture

// Service Bus — 'Reliable message delivery between services'
//               Order processing, workflow steps, dead-letter queues
//               Price: per operation + messaging units

Pubblicazione di eventi personalizzati

Pubblicare eventi personalizzati in un argomento di Event Grid usando una semplice richiesta HTTP POST con la chiave di accesso dell'argomento. Qualsiasi servizio o applicazione in grado di effettuare richieste HTTP può pubblicare eventi. Questo rende semplice generare eventi da applicazioni locali, servizi di terze parti o servizi Azure che non supportano nativamente Event Grid. È possibile raggruppare fino a 1 MB di eventi per ogni POST per una maggiore efficienza.

# Get the topic endpoint and key
TOPIC_ENDPOINT=$(az eventgrid topic show --name MyEventTopic --resource-group MyRG --query endpoint -o tsv)
TOPIC_KEY=$(az eventgrid topic key list --name MyEventTopic --resource-group MyRG --query key1 -o tsv)

# Publish a custom event
curl -X POST $TOPIC_ENDPOINT \
  -H 'Content-Type: application/json' \
  -H "aeg-sas-key: $TOPIC_KEY" \
  -d '[{
    "id": "event-001",
    "eventType": "Contoso.OrderPlaced",
    "subject": "/orders/ORD-12345",
    "eventTime": "2025-01-15T12:00:00Z",
    "data": { "orderId": "ORD-12345", "total": 99.99 },
    "dataVersion": "1.0"
  }]'

Criteri di retry e messaggi non recapitabili

Se un tentativo di distribuzione di un evento non riesce (il sottoscrittore restituisce una risposta HTTP diversa da 2xx), Event Grid riprova usando un backoff esponenziale con jitter per un massimo di 24 ore (configurabile fino a 72 ore), con un massimo di 30 tentativi. Dopo aver esaurito i tentativi, Event Grid può spostare gli eventi non recapitabili in un contenitore Azure Blob Storage per un'analisi manuale. Configuri l'archiviazione dei messaggi non recapitabili quando la distribuzione affidabile degli eventi è fondamentale e deve verificare o rielaborare gli eventi non riusciti.

# Configure dead-letter storage and retry for a subscription
az eventgrid event-subscription update \
  --name myFunctionSub \
  --source-resource-id '/subscriptions/.../topics/MyEventTopic' \
  --deadletter-endpoint '/subscriptions/.../storageAccounts/mystg/blobServices/default/containers/deadletter' \
  --max-delivery-attempts 30 \
  --event-ttl 1440  # 24 hours in minutes

Panoramica di Azure Event Hubs

Azure Event Hubs è una piattaforma distribuita di streaming dei dati in grado di ricevere ed elaborare milioni di eventi al secondo. Usa un modello di consumo partizionato: gli eventi vengono distribuiti tra le partizioni e ogni gruppo di consumer legge gli eventi in modo indipendente, al proprio ritmo. Ciò consente a più consumer di elaborare lo stesso stream senza coordinamento. I casi d'uso comuni includono l'acquisizione della telemetria IoT, l'aggregazione dei log delle applicazioni, l'analisi dei flussi di clic e le pipeline di dati per dashboard in tempo reale.

# Create an Event Hubs namespace and hub
az eventhubs namespace create \
  --name myEventHubNS \
  --resource-group MyRG \
  --location eastus \
  --sku Standard

az eventhubs eventhub create \
  --name telemetry \
  --namespace-name myEventHubNS \
  --resource-group MyRG \
  --partition-count 8 \
  --message-retention 3  # Days to retain events

Azure Service Bus per la messaggistica affidabile

Azure Service Bus è un broker di messaggistica enterprise che offre code (point-to-point) e argomenti con sottoscrizioni (publish-subscribe). A differenza di Event Grid (fire-and-forget) ed Event Hubs (streaming), Service Bus garantisce la distribuzione ordinata (code FIFO), il rilevamento dei duplicati, le code dei messaggi non recapitabili per gli errori di elaborazione, le sessioni dei messaggi per l'elaborazione raggruppata e le transazioni: tutte funzionalità essenziali per i flussi di elaborazione finanziaria e degli ordini.

# Create a Service Bus namespace and queue
az servicebus namespace create \
  --name myServiceBusNS \
  --resource-group MyRG \
  --location eastus \
  --sku Standard

az servicebus queue create \
  --name order-processing \
  --namespace-name myServiceBusNS \
  --resource-group MyRG \
  --enable-dead-lettering-on-message-expiration true \
  --max-delivery-count 10  # Move to dead-letter after 10 failed attempts

Pattern pratico basato sugli eventi: elaborazione dei file

Un pattern comune di Azure basato sugli eventi prevede che un utente carichi un file in Blob Storage, che genera un evento BlobCreated verso Event Grid. Event Grid instrada l'evento a una Azure Function che elabora il file (ridimensiona un'immagine, estrae il testo, convalida i dati) e scrive il risultato in Azure SQL Database. Se l'elaborazione non riesce, l'evento viene spostato in un contenitore di archiviazione per i messaggi non recapitabili. Questa intera pipeline non richiede alcun polling né risorse di calcolo persistenti quando è inattiva.

// Azure Function: process image on BlobCreated event
module.exports = async function (context, eventGridEvent) {
  const blobUrl = eventGridEvent.data.url;
  const blobName = eventGridEvent.subject.split('/blobs/').pop();

  context.log('Processing image:', blobName);

  // Process via Cognitive Services Vision API
  const tags = await analyzeImage(blobUrl);

  // Write metadata to Cosmos DB via output binding
  context.bindings.cosmosOutput = {
    id: blobName,
    tags,
    processedAt: new Date().toISOString()
  };

  context.log('Processing complete for:', blobName);
};

Verifica rapida

Verifichi la Sua comprensione dei concetti di Microsoft Azure Fundamentals (AZ-900) trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che Azure Event Grid instrada eventi discreti dai publisher ai subscriber usando la distribuzione push, il filtraggio e l'archiviazione dei messaggi non recapitabili; ha inoltre appreso la differenza fondamentale tra Event Grid (eventi reattivi), Event Hubs (streaming) e Service Bus (messaggistica enterprise affidabile), nonché come creare pipeline basate sugli eventi concatenando gli eventi di Blob Storage tramite Event Grid ad Azure Functions. Ora esamineremo i servizi Azure DevOps.

Domande Frequenti

La lezione «Event Grid e architettura event-driven» è gratuita?

Sì — il testo completo di «Event Grid e architettura event-driven» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Azure Fundamentals, passa a CoddyKit PRO. Il corso Azure Fundamentals include 4 lezioni in totale.

Cosa imparerò in «Event Grid e architettura event-driven»?

Instradi gli eventi dai servizi Azure e dai publisher personalizzati usando Event Grid, distribuiscili tra più subscriber e confronti Event Grid con Event Hubs e Service Bus. Eserciti Azure Fundamentals con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Azure Fundamentals?

Non è richiesta alcuna esperienza precedente. Azure Fundamentals su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Event Grid e architettura event-driven»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Azure Fundamentals?

Sì. Ogni lezione Azure Fundamentals include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Trigger e binding di Azure Functions
  2. Durable Functions per workflow con stato
  3. Azure Logic Apps
  4. Event Grid e architettura event-driven
← Torna a Azure Fundamentals