Azure Fundamentals · บทเรียน

Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์

บทเรียน 4 จาก 413 ขั้นตอน

Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ เป็นบทเรียน Azure Fundamentals ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Azure Fundamentals และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Azure Fundamentals มีบทเรียนทั้งหมด 4 บทเรียน

สถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์คืออะไร

ใน สถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ ส่วนประกอบต่าง ๆ จะสื่อสารกันด้วยการเผยแพร่และสมัครรับเหตุการณ์ แทนการเรียกหากันโดยตรง ส่วนประกอบหนึ่ง (ผู้ผลิต) จะส่งเหตุการณ์ออกมาเมื่อเกิดสิ่งที่สำคัญ เช่น มีการอัปโหลดไฟล์ มีการส่งคำสั่งซื้อ หรืออุปกรณ์ส่งค่าการอ่าน ส่วนประกอบอื่น ๆ (ผู้สมัครรับ) จะตอบสนองต่อเหตุการณ์ที่ตนสนใจอย่างเป็นอิสระและไม่พร้อมกัน วิธีนี้แยกผู้ผลิตออกจากผู้ใช้ข้อมูล ช่วยเพิ่มความสามารถในการปรับขนาด ความทนทานต่อความล้มเหลว และความสามารถในการบำรุงรักษา

Azure Event Grid คืออะไร

Azure Event Grid คือบริการกำหนดเส้นทางเหตุการณ์ที่มีการจัดการเต็มรูปแบบ ซึ่งส่งเหตุการณ์จากแหล่งที่มา (ผู้เผยแพร่) ไปยังตัวจัดการ (ผู้สมัครรับ) โดยใช้ รูปแบบการส่งแบบผลัก Event Grid ออกแบบมาสำหรับ เหตุการณ์แบบตอบสนองและเกิดขึ้นเป็นครั้ง ๆ กล่าวคือ มีบางสิ่งเปลี่ยนแปลงและคุณต้องตอบสนองทันที บริการนี้รับประกันการส่งอย่างน้อยหนึ่งครั้ง โดยมีการลองใหม่โดยอัตโนมัติ รองรับการกรองเพื่อให้ผู้สมัครรับได้รับเฉพาะเหตุการณ์ที่เกี่ยวข้อง และสามารถกำหนดเส้นทางเหตุการณ์ไปยัง Azure Functions, Logic Apps, เว็บฮุก, Event Hubs และคิว Service Bus ได้

หัวข้อ Event Grid และการสมัครรับเหตุการณ์

ผู้เผยแพร่จะส่งเหตุการณ์ไปยังหัวข้อ Event Grid ผู้สมัครรับจะสร้างการสมัครรับเหตุการณ์ในหัวข้อ โดยระบุจุดปลายทางและกฎการกรองเพิ่มเติมตามต้องการ หัวข้อเดียวสามารถมีการสมัครรับได้หลายรายการ โดยแต่ละรายการจะได้รับสำเนาเหตุการณ์ที่ตรงกันแยกเป็นอิสระ บริการ Azure เช่น Blob Storage, Resource Manager, Service Bus และ Azure Container Registry เป็นแหล่งเหตุการณ์ในตัวที่มีหัวข้อระบบและไม่ต้องกำหนดค่าเพิ่มเติม

# 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'

สคีมาเหตุการณ์

เหตุการณ์ที่เผยแพร่ไปยัง Event Grid จะใช้สคีมา JSON มาตรฐานที่มีฟิลด์บังคับ ได้แก่ id (ตัวระบุที่ไม่ซ้ำกัน), eventType (เช่น Microsoft.Storage.BlobCreated), subject (เส้นทางไปยังทรัพยากรของเหตุการณ์), eventTime (การประทับเวลาตาม ISO 8601), dataVersion และ data (ข้อมูลของเหตุการณ์นั้น ๆ) Event Grid ยังรองรับ สคีมา CloudEvents (มาตรฐาน CNCF) เพื่อให้ทำงานร่วมกับแพลตฟอร์มเหตุการณ์อื่นได้

// 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'
  }
]

การกรองเหตุการณ์

การสมัครรับเหตุการณ์รองรับการกรองเพื่อลดเหตุการณ์รบกวนที่ฝั่งผู้สมัครรับ คุณสามารถกรองตามประเภทเหตุการณ์ (รับเฉพาะ BlobCreated ไม่รับ BlobDeleted) ตามคำนำหน้าหรือคำลงท้ายของหัวข้อ (รับเฉพาะ Blob ในคอนเทนเนอร์ที่กำหนด) หรือตามตัวกรองขั้นสูงในฟิลด์ใดก็ได้ของข้อมูลเหตุการณ์ โดยใช้ตัวดำเนินการ เช่น StringContains, NumberGreaterThan และ BoolEquals การกรองเกิดขึ้นที่ฝั่งเซิร์ฟเวอร์ ดังนั้นผู้สมัครรับจึงได้รับเฉพาะเหตุการณ์ที่ตรงตามเกณฑ์

# 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 และ Service Bus

บริการ Azure สามรายการนี้ใช้จัดการเหตุการณ์และข้อความ โดยควรเลือกตามสถานการณ์ของคุณ Event Grid ใช้สำหรับการกำหนดเส้นทางเหตุการณ์แบบตอบสนอง (ปริมาณต่ำ เหตุการณ์เกิดขึ้นเป็นครั้ง ๆ และต้องตอบสนอง เช่น การแจ้งเตือนเมื่อทรัพยากรเปลี่ยนแปลง) Event Hubs ใช้สำหรับการสตรีมเหตุการณ์ปริมาณมาก (หลายล้านเหตุการณ์ต่อวินาที ข้อมูลการวัด และไปป์ไลน์ข้อมูลขนาดใหญ่) Service Bus ใช้สำหรับการส่งข้อความระดับองค์กรที่ต้องมีการจัดลำดับ การตรวจจับข้อความซ้ำ การส่งไปยังคิวจดหมายตาย และธุรกรรม (การประมวลผลคำสั่งซื้อและธุรกรรมทางการเงิน)

// 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

การเผยแพร่เหตุการณ์แบบกำหนดเอง

เผยแพร่เหตุการณ์แบบกำหนดเองไปยังหัวข้อ Event Grid โดยใช้คำขอ HTTP POST อย่างง่ายพร้อมคีย์การเข้าถึงของหัวข้อ บริการหรือแอปพลิเคชันใดก็ตามที่ส่งคำขอ HTTP ได้ก็สามารถเผยแพร่เหตุการณ์ได้ วิธีนี้ทำให้การส่งเหตุการณ์จากแอปพลิเคชันภายในองค์กร บริการของบริษัทอื่น หรือบริการ Azure ที่ไม่รองรับ Event Grid ในตัวเป็นเรื่องง่าย คุณสามารถรวมเหตุการณ์ได้สูงสุด 1 MB ต่อ POST เพื่อเพิ่มประสิทธิภาพ

# 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"
  }]'

นโยบายจดหมายตายและการลองใหม่

หากการพยายามส่งเหตุการณ์ล้มเหลว (ผู้สมัครรับส่ง HTTP ที่ไม่ใช่ 2xx กลับมา) Event Grid จะลองใหม่โดยใช้การหน่วงเวลาแบบทวีคูณพร้อมการสุ่มเวลาเล็กน้อย นานสูงสุด 24 ชั่วโมง (กำหนดค่าได้สูงสุด 72 ชั่วโมง) และลองใหม่ได้สูงสุด 30 ครั้ง เมื่อใช้จำนวนครั้งในการลองใหม่ครบแล้ว Event Grid สามารถส่งเหตุการณ์ที่ส่งไม่สำเร็จไปยังจดหมายตายในคอนเทนเนอร์ Azure Blob Storage เพื่อให้ตรวจสอบด้วยตนเองได้ ควรกำหนดค่าจดหมายตายเมื่อการส่งเหตุการณ์ที่เชื่อถือได้เป็นสิ่งสำคัญ และคุณต้องตรวจสอบย้อนหลังหรือประมวลผลเหตุการณ์ที่ล้มเหลวใหม่

# 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

ภาพรวม Azure Event Hubs

Azure Event Hubs คือแพลตฟอร์มสตรีมข้อมูลแบบกระจายที่สามารถรับและประมวลผลเหตุการณ์ได้หลายล้านรายการต่อวินาที โดยใช้รูปแบบผู้ใช้ข้อมูลแบบแบ่งพาร์ติชัน เหตุการณ์จะถูกกระจายไปยังพาร์ติชันต่าง ๆ และแต่ละกลุ่มผู้ใช้ข้อมูลจะอ่านเหตุการณ์อย่างเป็นอิสระตามความเร็วของตนเอง วิธีนี้ช่วยให้ผู้ใช้ข้อมูลหลายรายประมวลผลสตรีมเดียวกันได้โดยไม่ต้องประสานงานกัน กรณีใช้งานทั่วไป ได้แก่ การรับข้อมูลการวัดจาก IoT การรวมบันทึกของแอปพลิเคชัน การวิเคราะห์สตรีมการคลิก และไปป์ไลน์ข้อมูลสำหรับแดชบอร์ดแบบเรียลไทม์

# 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 สำหรับการส่งข้อความที่เชื่อถือได้

Azure Service Bus คือตัวกลางรับส่งข้อความระดับองค์กรที่ให้บริการทั้งคิว (จุดต่อจุด) และหัวข้อพร้อมการสมัครรับ (เผยแพร่และสมัครรับ) ต่างจาก Event Grid (ส่งแล้วไม่รอผลตอบกลับ) และ Event Hubs (สตรีมมิง) Service Bus รับประกันการส่งตามลำดับ (คิว FIFO) การตรวจจับข้อความซ้ำ คิวจดหมายตายสำหรับความล้มเหลวในการประมวลผล เซสชันข้อความสำหรับการประมวลผลเป็นกลุ่ม และธุรกรรม ซึ่งทั้งหมดจำเป็นสำหรับลำดับงานด้านการเงินและการประมวลผลคำสั่งซื้อ

# 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

รูปแบบที่ขับเคลื่อนด้วยเหตุการณ์ในทางปฏิบัติ: การประมวลผลไฟล์

รูปแบบที่ขับเคลื่อนด้วยเหตุการณ์บน Azure ที่ใช้กันทั่วไปคือ ผู้ใช้อัปโหลดไฟล์ไปยัง Blob Storage ซึ่งจะส่งเหตุการณ์ BlobCreated ไปยัง Event Grid จากนั้น Event Grid จะกำหนดเส้นทางเหตุการณ์ไปยัง Azure Function เพื่อประมวลผลไฟล์ (ปรับขนาดรูปภาพ แยกข้อความ หรือตรวจสอบความถูกต้องของข้อมูล) และเขียนผลลัพธ์ไปยัง Azure SQL Database หากการประมวลผลล้มเหลว เหตุการณ์จะถูกส่งไปยังจดหมายตายในคอนเทนเนอร์จัดเก็บข้อมูล ไปป์ไลน์ทั้งหมดนี้ไม่ต้องใช้การสำรวจเป็นระยะ และไม่ต้องใช้การประมวลผลแบบถาวรในช่วงที่ไม่มีงาน

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิด Microsoft Azure Fundamentals (AZ-900) จากบทเรียนนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า Azure Event Grid กำหนดเส้นทางเหตุการณ์ที่เกิดขึ้นเป็นครั้ง ๆ จากผู้เผยแพร่ไปยังผู้สมัครรับด้วยการส่งแบบผลัก พร้อมการกรองและการส่งไปยังจดหมายตาย ได้เห็นความแตกต่างสำคัญระหว่าง Event Grid (เหตุการณ์แบบตอบสนอง), Event Hubs (สตรีมมิง) และ Service Bus (การส่งข้อความระดับองค์กรที่เชื่อถือได้) และได้เรียนรู้วิธีสร้างไปป์ไลน์ที่ขับเคลื่อนด้วยเหตุการณ์โดยเชื่อมเหตุการณ์จาก Blob Storage ผ่าน Event Grid ไปยัง Azure Functions ต่อไปเราจะศึกษาเกี่ยวกับบริการ Azure DevOps

เริ่มต้นได้ฟรี

เรียนรู้ Azure Fundamentals ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 30
บทเรียน: 120

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Azure Fundamentals ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Azure Fundamentals มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์”

กำหนดเส้นทางเหตุการณ์จากบริการ Azure และผู้เผยแพร่แบบกำหนดเองโดยใช้ Event Grid กระจายเหตุการณ์ไปยังผู้สมัครรับข้อมูลหลายราย และเปรียบเทียบ Event Grid กับ Event Hubs และ Service Bus คุณปฏิบัติ Azure Fundamentals ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Azure Fundamentals หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Azure Fundamentals บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Azure Fundamentals นี้ได้ไหม

ได้ บทเรียน Azure Fundamentals ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

ทริกเกอร์และการผูกของ Azure Functions
Durable Functions สำหรับเวิร์กโฟลว์ที่มีสถานะ
Azure Logic Apps
Event Grid และสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์

← กลับไปที่ Azure Fundamentals