Courseiva

CCNA Event Driven Integration Questions

75 of 100 questions · Page 1/2 · Event Driven Integration · Answers revealed

Practice these questionsDomain overviewAll questions
1
MCQeasy

You are building a serverless AI workflow that triggers an Azure Function whenever a new file is uploaded to an Azure Blob Storage container. The Function must start processing within seconds of the upload and should not require polling. Which Azure service should you use to connect Blob Storage to the Function?

A.Azure Queue Storage
B.Azure Event Grid
C.Azure Service Bus
D.Azure Event Hubs
AnswerB

Azure Event Grid is a fully managed event routing service that can subscribe to Blob Storage events such as BlobCreated. When a file is uploaded, Event Grid pushes the event to the Function endpoint, providing near real-time, push-based delivery without polling. This is the recommended approach for reactive serverless workflows triggered by Blob Storage changes.

Why this answer

Azure Event Grid natively integrates with Blob Storage to publish events like BlobCreated, and it can push these events directly to an Azure Function. This provides a serverless, push-based trigger that processes files within seconds without polling, making it the correct choice for the scenario.

Exam trap

The trap here is assuming that any messaging service can trigger a Function on Blob Storage upload, when only Event Grid provides native, push-based eventing from Blob Storage.

Practice this question →
2
MCQmedium

You are managing an Azure Service Bus Premium namespace. Your application requires strict transactional messaging where a worker receives a message from Queue A, processes it, and sends a resulting message to Queue B. If any step fails, both actions must be rolled back. How should you implement this?

A.Wrap the receive and send operations inside a .NET TransactionScope block.
B.Set the message session ID to the same value on both queues.
C.Enable Event Grid automatic forwarding between queues.
D.Use Event Hubs checkpoints for transactional rollback.
AnswerA

A .NET TransactionScope block enlists both the Queue A receive and Queue B send into a single atomic transaction, so Service Bus rolls back both operations if any step fails, meeting the strict transactional requirement.

Why this answer

In Azure Service Bus, transactional messaging across multiple entities (like receiving from one queue and sending to another) can be achieved using the .NET TransactionScope class. This ensures that both operations are committed or rolled back together.

Exam trap

AI-200 often tests the use of TransactionScope for atomic operations in Service Bus. Candidates might confuse session IDs or auto-forwarding as transactional mechanisms, but only TransactionScope provides rollback.

How to eliminate wrong answers

Option B is wrong because setting the same session ID does not provide transactional rollback; it only ensures ordered processing within a session. Option C is wrong because Event Grid automatic forwarding is not transactional and does not support rollback. Option D is wrong because Event Hubs checkpoints are for stream processing offset management, not for transactional messaging in Service Bus.

Practice this question →
3
MCQmedium

You are building an order processing system with Azure Service Bus. Multiple clients might accidentally submit the exact same order twice within a 60-second window due to network retries. You need to prevent duplicate orders from entering the queue. What should you configure?

A.Enable Duplicate Detection on the queue and set the history time window to 60 seconds.
B.Configure Auto-Forwarding to a dead-letter queue with a 60-second TTL.
C.Set the LockDuration property to 60 seconds.
D.Enable partitioning and set the partition key to the client IP address.
AnswerA

Service Bus duplicate detection uses the MessageId to identify and discard repeated messages within a configurable history window. Setting the window to 60 seconds covers the retry interval, preventing the same order from being enqueued twice.

Why this answer

Azure Service Bus Duplicate Detection uses a DuplicateDetectionHistoryTimeWindow to track MessageId values of recently sent messages. When enabled, the broker rejects messages with the same MessageId within the specified window. Setting the window to 60 seconds ensures that duplicate orders submitted within that timeframe are discarded, preventing duplicates from entering the queue.

Exam trap

AI-200 often tests the misconception that message locks or TTL settings prevent duplicates, when the correct feature is Duplicate Detection with a history time window.

How to eliminate wrong answers

Option B is wrong because Auto-Forwarding to a dead-letter queue with a TTL does not detect duplicates; it simply moves expired messages, and duplicates would still be processed. Option C is wrong because LockDuration controls how long a receiver can lock a message, not duplicate detection. Option D is wrong because partitioning with a partition key based on client IP does not prevent duplicates; it only distributes load and does not compare message IDs.

Practice this question →
4
MCQmedium

Your application uses Azure Service Bus Queues. A spike in traffic causes multiple worker instances to contend for messages. You want to ensure that when a worker locks a message, no other worker can process it, and the lock is automatically renewed in the background if processing takes longer than expected. Which client library feature should you use?

A.Enable Auto-Lock Renewal on the message processor client.
B.Increase the LockDuration property on the queue to 2 hours permanently.
C.Use Event Grid advanced filters to throttle incoming messages.
D.Switch the queue to ReceiveAndDelete mode.
AnswerA

Auto-Lock Renewal extends the PeekLock before expiry, preventing lock loss and duplicate processing by other workers during long runs. Combined with PeekLock's exclusive lock, it satisfies the stem's requirement that no other worker processes the message.

Why this answer

Auto-Lock Renewal is a feature of the Service Bus message processor client (e.g., ServiceBusProcessor in .NET, ServiceBusProcessorClient in Java) that automatically extends the message lock in the background while the handler is still processing. This prevents lock expiration and message redelivery to other workers during long-running processing.

Exam trap

AI-200 often tests the difference between lock renewal (dynamic, per-message) and LockDuration (static, queue-level) — candidates pick the static LockDuration increase because it seems simpler, missing that auto-renewal is the adaptive, correct solution.

How to eliminate wrong answers

Option A is correct. Option B is wrong because permanently setting LockDuration to 2 hours is a blunt, static workaround that affects all messages and can delay redelivery of genuinely failed messages for up to 2 hours — it does not adapt to actual processing time. Option C is wrong because Event Grid advanced filters apply to Event Grid subscriptions, not Service Bus queues, and they filter events rather than throttle message consumption.

Option D is wrong because ReceiveAndDelete mode removes the message from the queue immediately upon receipt, eliminating the lock entirely and providing at-most-once delivery — the opposite of what is needed for reliable processing.

Practice this question →
5
MCQmedium

Your team is building an analytics pipeline where IoT telemetry data is ingested via Azure Event Hubs and needs to be continuously archived in Parquet format to an Azure Data Lake Storage Gen2 account for AI model training. Which built-in feature of Event Hubs should you enable?

A.Service Bus Geo-Replication
B.Event Grid Auto-Routing
C.Event Hubs Capture
D.Stream Analytics Integration Job
AnswerC

Event Hubs Capture automatically packages streaming telemetry into storage blobs without requiring custom worker code.

Why this answer

Event Hubs Capture allows you to automatically capture streaming data in Event Hubs and save it to an Azure Blob Storage or Azure Data Lake Storage Gen2 account in Avro or Parquet format.

Practice this question →
6
MCQhard

Your enterprise application uses Azure Service Bus Topics to broadcast AI model inference updates to multiple microservices. One particular subscriber requires filtering messages so it only receives updates where the 'ModelVersion' property is equal to 'v2' and the 'ConfidenceScore' is greater than 0.85. How should you implement this?

A.Create a boolean filter on the subscription matching a correlation ID of 'v2'.
B.Write custom middleware in the subscriber service to drop messages that do not meet the criteria after reading them from the topic.
C.Configure an Event Grid custom filter using advanced filters with an 'And' operator.
D.Create a SQL filter on the Service Bus subscription with the expression ModelVersion = 'v2' AND ConfidenceScore > 0.85.
AnswerD

SQL filters evaluate broker-side Boolean expressions against message properties, so ModelVersion = 'v2' AND ConfidenceScore > 0.85 is applied before delivery. This satisfies the stem's compound filtering constraint, which correlation filters cannot express because they only match exact property values.

Why this answer

Azure Service Bus subscriptions support SQL filters that evaluate against both system properties and user-defined custom properties (also called application properties) on the message. Because 'ModelVersion' and 'ConfidenceScore' are custom properties set by the publisher, a SQL filter expression like ModelVersion = 'v2' AND ConfidenceScore > 0.85 evaluates server-side at the subscription, so only matching messages are delivered to that subscriber. This is the native, most efficient mechanism for content-based routing on Service Bus Topics.

Exam trap

AI-200 often tests the misconception that subscriber-side middleware or Event Grid filters can replace native Service Bus subscription filters, when the correct answer is always the broker-side SQL filter for content-based routing on Service Bus Topics.

How to eliminate wrong answers

Option A is wrong because a boolean filter (TrueFilter/FalseFilter) only accepts or rejects all messages and cannot evaluate a correlation ID against a custom property like ModelVersion — correlation filters match only the CorrelationId system property, not arbitrary application properties. Option B is wrong because filtering after the subscriber reads the message means every message is still delivered to every subscriber, wasting bandwidth and compute, and it defeats the purpose of the topic/subscription fan-out model. Option C is wrong because Event Grid custom filters apply to Event Grid events, not Service Bus messages, and Event Grid is a separate eventing service — it cannot filter Service Bus topic subscriptions.

Practice this question →
7
MCQhard

You are designing an AI inference pipeline that publishes prediction results to an Azure Event Hubs namespace with four partitions. A downstream Azure Function must process events in the exact order they were produced for each customer ID, and the pipeline must scale to handle increasing load. The customer ID is included in the event body as a property. What should you do to guarantee per-customer ordering while maximizing throughput?

A.Set the partition key to the customer ID when publishing events, and have each Function instance process a single partition.
B.Publish events without a partition key and enable the Event Hubs capture feature to archive events in order.
C.Enable the Event Hubs deduplication feature and set a sequence number on each event before publishing.
D.Use a single partition for the Event Hubs namespace and scale the Function with multiple instances reading from that partition.
AnswerA

Event Hubs guarantees ordering only within a partition. By setting the partition key to the customer ID, all events for a given customer are routed to the same partition, preserving order. Having each Function instance read from a single partition ensures sequential processing per partition, which maintains per-customer order while allowing the four partitions to be processed in parallel for throughput.

Why this answer

Ordering in Event Hubs is guaranteed only within a partition. Setting the partition key to the customer ID ensures all events for that customer go to the same partition, and having each Function instance read from a single partition preserves sequential processing. This design also allows the four partitions to be processed concurrently, meeting the scaling requirement.

Exam trap

The trap here is believing that Event Hubs offers global ordering or that a single partition with multiple readers can scale, when ordering is per-partition and a partition supports only one active reader per consumer group.

Practice this question →
8
Multi-Selectmedium

You are configuring an Azure Service Bus Topic and Subscriptions for an AI text classification system. Which THREE filter types are supported on Service Bus subscriptions for routing messages? Each correct answer represents a valid filter type.

Select 3 answers
A.Boolean Filters (True/False filters)
B.Regex Pattern Matching Filters
C.Machine Learning Inference Filters
D.SQL Filters
E.Correlation Filters
AnswersA, D, E

Boolean filters are the TrueFilter and FalseFilter, which match all messages or none respectively, giving subscriptions an unconditional catch-all or complete block. They are a supported Service Bus subscription filter type, distinct from SQL and correlation filters.

Why this answer

Service Bus subscriptions support exactly three filter types: Boolean filters, SQL filters, and Correlation filters. Option A (Boolean Filters) is correct because a TrueFilter (1=1) captures all messages to a subscription and a FalseFilter (1=0) blocks all messages, which is useful for a catch-all or disabled subscription in the classification pipeline. Option D (SQL Filters) is correct because they use SQL-like expressions evaluated against message system and user properties (for example, sys.Label='sports' AND priority>5), enabling content-based routing of text classification messages.

Option E (Correlation Filters) is correct because they match on properties such as CorrelationId, MessageId, Label, ReplyTo, and custom properties, providing efficient exact-match routing for AI workloads. Option B (Regex Pattern Matching Filters) is not a supported Service Bus filter type, and Option C (Machine Learning Inference Filters) does not exist as a native subscription filter; both are invalid for this scenario.

Exam trap

AI-200 often tests the exact set of Service Bus filter types, and candidates pick regex or ML-based filters because they sound advanced — the trap is not knowing that only Boolean, SQL, and Correlation filters exist.

Practice this question →
9
Multi-Selecthard

You are designing an event-driven architecture that needs to integrate multiple Azure services. Which THREE statements accurately describe the ideal use cases for Azure Event Grid, Azure Service Bus, and Azure Event Hubs respectively? (Choose three)

Select 3 answers
A.Azure Event Hubs is designed for high-throughput big data streaming and telemetry ingestion pipelines.
B.Azure Event Grid is designed for high-speed Kafka protocol big data telemetry streaming.
C.Azure Event Grid is optimized for reactive event distribution and pub/sub routing across Azure services.
D.Azure Service Bus is optimized for stateless event notifications with sub-millisecond webhook delivery.
E.Azure Service Bus is designed for enterprise transactional messaging, queues, topics, and strict ordering.
AnswersA, C, E

Event Hubs partitions a high-volume event stream for replayable, ordered consumption by multiple downstream readers, making it the fit for telemetry and big-data ingestion where throughput, retention and consumer groups matter rather than per-message routing or transactions.

Why this answer

Option A is correct because Azure Event Hubs is a big-data streaming platform built for ingesting millions of events per second from telemetry, logs, and IoT sources into pipelines like Azure Stream Analytics or Spark. Option C is correct because Azure Event Grid is a reactive, push-based pub/sub service that routes discrete event notifications from Azure resource events and custom topics to subscribers such as Functions, Logic Apps, and webhooks. Option E is correct because Azure Service Bus provides enterprise brokering with queues, topics/subscriptions, sessions, transactions, dead-lettering, and guaranteed FIFO ordering via sessions.

Option B is wrong because Kafka-protocol streaming is a feature of Event Hubs (Kafka endpoint), not Event Grid. Option D is wrong because Service Bus is a brokered messaging service with at-least-once delivery and store-and-forward semantics, not a stateless sub-millisecond webhook notifier like Event Grid.

Exam trap

AI-200 often tests the Kafka protocol confusion — candidates assume Event Grid supports Kafka because it sounds like a streaming service, but only Event Hubs offers the Kafka-compatible endpoint.

Practice this question →
10
MCQhard

You are designing a disaster recovery strategy for an Azure Event Hubs namespace. You configure Geo-Disaster Recovery pairing between a primary region (East US) and a secondary region (West US). During a disaster drill, you trigger a failover. What happens to the DNS alias pointing to the Event Hubs namespace?

A.The primary namespace automatically becomes the replica of the secondary namespace without breaking the pair.
B.The alias is automatically updated to point to the secondary namespace, enabling client reconnection without changing connection strings.
C.The alias enters a Read-Only state for 24 hours while DNS propagation finishes globally.
D.The alias is permanently deleted and clients must be hardcoded with the secondary namespace connection string.
AnswerB

Geo-Disaster Recovery uses a namespace DNS alias rather than hard-coded endpoints. On failover, the alias is repointed to the secondary namespace automatically, so clients reconnect using unchanged connection strings, satisfying the drill's requirement for transparent failover.

Why this answer

Geo-Disaster Recovery in Azure Event Hubs uses a DNS alias (namespace hostname) that abstracts the primary and secondary namespaces. When you trigger a failover, the alias's DNS CNAME record is automatically repointed to the secondary namespace, so clients using the alias connection string reconnect without any configuration change. This is the core value of the alias-based failover model.

Exam trap

AI-200 often tests the misconception that failover requires changing connection strings or that the alias is deleted; the key is that the alias is automatically repointed so clients using the alias reconnect transparently.

How to eliminate wrong answers

Option A is wrong because after failover the primary namespace becomes the new secondary (replica) only after the pairing is re-established/break-pair is performed; the alias does not silently swap roles without breaking the pair. Option C is wrong because there is no 24-hour read-only DNS state — the alias is updated immediately upon failover, not placed in a read-only hold. Option D is wrong because the alias is never deleted; it is repointed, which is precisely why clients do not need to hardcode the secondary connection string.

Practice this question →
11
MCQeasy

An AI pipeline uses Azure Service Bus Queues. You want to inspect the number of messages currently residing in a queue waiting to be processed without actually receiving or locking them. Which Azure Portal section or metric should you check?

A.The Azure Storage Account queued message monitoring graphs.
B.The Event Grid subscription delivery status log.
C.The Event Hubs capture storage container file list.
D.The Service Bus Queue 'Overview' blade displaying Active Message Count metrics.
AnswerD

The Overview blade's Active Message Count metric reports messages available for delivery without receiving or locking them, satisfying the requirement to inspect queue depth non-destructively. Unlike peek-lock operations, which alter lock state, this metric is purely observational, giving the current waiting-message count directly.

Why this answer

The Service Bus Queue 'Overview' blade in the Azure Portal displays the Active Message Count metric, which reports the number of messages currently in the queue that are ready to be received. This is a non-destructive metric — it does not lock or receive messages — and is the standard way to inspect queue depth.

Exam trap

AI-200 often tests whether candidates can distinguish Service Bus queue metrics from Storage Queue, Event Grid, and Event Hubs telemetry, causing them to pick a monitoring surface for the wrong service.

How to eliminate wrong answers

Option A is wrong because Azure Storage Account queued message monitoring applies to Storage Queues, not Service Bus Queues, and is a different service entirely. Option B is wrong because Event Grid subscription delivery status logs track event delivery attempts, not Service Bus queue depth. Option C is wrong because Event Hubs Capture storage containers hold archived Event Hubs data, which has no relationship to Service Bus queue message counts.

Practice this question →
12
MCQeasy

An application publishes custom events to an Azure Event Grid topic. You want to inspect the dead-lettered events that failed delivery after the maximum retry period. Where must you configure the dead-letter destination?

A.Azure SQL Database table
B.Local App Service temporary file system
C.Azure Blob Storage container
D.Azure Service Bus Dead-Letter Queue
AnswerC

Dead-lettering in Azure Event Grid requires a blob storage container as the destination, configured on the event subscription. Event Grid writes failed events there after exhausting retries, satisfying the requirement to inspect undelivered custom events. No other service supports this dead-letter target.

Why this answer

Event Grid dead-lettering requires an Azure Blob Storage container as the destination, configured on the event subscription. When an event fails all delivery retries (default 30 attempts over 24 hours), it is written to that container as a blob so you can inspect and reprocess it. Blob Storage is the only supported dead-letter target for Event Grid.

Exam trap

The trap here is confusing Event Grid dead-lettering (Blob Storage only) with Service Bus dead-letter queues, which are a completely separate mechanism tied to Service Bus messaging.

How to eliminate wrong answers

Option A is wrong because Event Grid cannot write dead-lettered events directly to an Azure SQL Database table — there is no native SQL sink for dead-lettering. Option B is wrong because the App Service local file system is ephemeral, not durable, and not an Event Grid-supported destination. Option D is wrong because Service Bus DLQs apply to Service Bus messages that fail processing within a Service Bus queue/topic subscription, not to Event Grid delivery failures — the two dead-letter concepts are unrelated.

Practice this question →
13
Multi-Selectmedium

You are troubleshooting event delivery failures in Azure Event Grid. Which TWO mechanisms can help you analyze or recover undeliverable events? (Choose two)

Select 2 answers
A.Configuring a Dead-Letter destination pointing to an Azure Blob Storage container
B.Enabling Service Bus message session locks on the event subscription
C.Viewing delivery metrics and logs via Azure Monitor diagnostic settings
D.Running the az servicebus queue purge command
E.Using Event Hubs Capture to replay webhook HTTP headers
AnswersA, C

Dead-lettering redirects events that Event Grid cannot deliver after retries to a Blob Storage container, preserving the original payload and failure metadata. This directly satisfies the troubleshooting requirement to analyse and recover undeliverable events rather than losing them silently.

Why this answer

Option A is correct because Azure Event Grid supports a dead-letter destination (typically an Azure Blob Storage container) where events that cannot be delivered after all retry attempts are stored, allowing you to inspect and later reprocess the undeliverable events. Option C is correct because enabling Azure Monitor diagnostic settings on the Event Grid topic or subscription lets you route delivery and publish metrics plus resource logs (e.g., DeliveryFailures, DroppedEvents) to Log Analytics, Storage, or Event Hubs, which is the standard way to analyze delivery failures. Option B is not applicable because Service Bus session locks are a Service Bus feature for ordered, session-aware message consumption, not an Event Grid delivery-recovery mechanism.

Option D is wrong because 'az servicebus queue purge' deletes messages from a Service Bus queue and has nothing to do with Event Grid undeliverable events. Option E is wrong because Event Hubs Capture writes event data to storage in Avro format and does not replay webhook HTTP headers for Event Grid.

Exam trap

AI-200 often tests whether candidates confuse Event Grid with Service Bus or Event Hubs; the trap is selecting Service Bus or Event Hubs features (session locks, queue purge, Capture) that sound related but do not apply to Event Grid delivery failures.

Practice this question →
14
MCQmedium

You are building an AI-powered order processing system. A web app publishes order events to an Azure Event Grid custom topic. A downstream Azure Function must process each event and, if processing fails, the event should be retried automatically by Event Grid. You configure the event subscription with a dead-letter destination. After a few days, you notice that some events were not processed successfully and were not delivered to the dead-letter destination. You need to ensure that failed events are captured for later analysis. What should you do?

A.Verify that the dead-letter destination (a storage account container) exists and that the managed identity has the necessary permissions.
B.Change the event subscription endpoint type from Azure Function to Webhook.
C.Increase the event subscription's retry policy maximum delivery attempts.
D.Enable the 'Always deliver' option on the event subscription.
AnswerA

For Event Grid to dead-letter events, the dead-letter destination must be correctly configured and accessible. If the storage account container does not exist or the managed identity lacks the Storage Blob Data Contributor role, Event Grid cannot write the dead-lettered events. This is a common misconfiguration. Ensuring the destination exists and permissions are granted will allow failed events to be captured.

Why this answer

Event Grid dead-letters an event only after all retry attempts are exhausted and if the dead-letter destination is properly configured. The most common reason for events not appearing in dead-letter storage is that the storage container does not exist or the managed identity used by the event subscription lacks write permissions. Verifying these settings ensures that failed events are captured for later analysis.

Exam trap

The trap here is assuming that enabling dead-lettering automatically works without verifying the destination's existence and permissions.

Practice this question →
15
MCQhard

You are designing a high-scale event ingestion pipeline using Azure Event Hubs in a secure enterprise environment. Public internet access must be disabled entirely. Producers and consumers reside in a peered Virtual Network (VNet). How should you configure network connectivity to the Event Hubs namespace?

A.Enable Service Bus Relay hybrid connections across the VNet gateway.
B.Configure Private Endpoints for the Event Hubs namespace and disable public network access.
C.Deploy an Azure Bastion host in the subnet connected to the Event Hubs SAS key manager.
D.Configure IP firewall rules to allow the default gateway IP of the VNet.
AnswerB

A private endpoint creates a private IP address for the namespace inside your peered VNet via Azure Private Link, so producers and consumers reach Event Hubs over the Microsoft backbone. Disabling public network access then blocks all internet ingress, satisfying the no-public-access constraint.

Why this answer

Azure Private Endpoints create a private IP address for the Event Hubs namespace inside your VNet via Azure Private Link, and disabling public network access ensures all traffic flows over the Microsoft backbone rather than the internet. This is the canonical pattern for fully private, enterprise-grade Event Hubs connectivity from peered VNets.

Exam trap

AI-200 often tests the misconception that IP firewall rules or Bastion provide private connectivity, when only Private Endpoints with public access disabled achieve true network isolation for Event Hubs.

How to eliminate wrong answers

Option A is wrong because Service Bus Relay hybrid connections are a separate service for on-premises-to-cloud bridging and do not provide private IP connectivity to Event Hubs namespaces. Option C is wrong because Azure Bastion is a jump-host service for RDP/SSH access to VMs — it has no role in Event Hubs network connectivity and cannot interact with SAS key management. Option D is wrong because IP firewall rules still expose the namespace to the public internet (they just restrict source IPs), and the VNet's default gateway IP is not a valid producer identity for Event Hubs.

Practice this question →
16
MCQeasy

Your organization uses Azure Event Grid namespaces for MQTT client messaging in an industrial IoT scenario. Which authentication method should you configure for IoT devices connecting directly to the Event Grid namespace MQTT broker?

A.SQL Database connection strings
B.Anonymous access with IP restriction headers
C.OAuth 2.0 client credentials grant via Service Bus endpoints
D.X.509 client certificates
AnswerD

X.509 client certificates let each IoT device authenticate to the Event Grid namespace MQTT broker using a unique cryptographic identity, satisfying the industrial requirement for direct, credential-free device connections without shared secrets or SAS tokens.

Why this answer

Azure Event Grid namespaces support MQTT v3.1.1 and v5.0, and for direct device connections the recommended and supported authentication method is X.509 client certificates. Devices present a client certificate during the TLS handshake, and Event Grid validates it against a trusted CA or thumbprint. This is the standard for IoT device authentication in Event Grid MQTT broker.

Exam trap

AI-200 often tests whether candidates confuse Event Grid MQTT authentication with Event Hubs or Service Bus authentication, so picking OAuth or SAS-based options instead of X.509 client certificates is the common error.

How to eliminate wrong answers

Option A is wrong because SQL Database connection strings are for database access, not MQTT broker authentication. Option B is wrong because anonymous access with IP restriction headers is not a supported authentication method for Event Grid MQTT and would be insecure. Option C is wrong because OAuth 2.0 client credentials via Service Bus endpoints is not how Event Grid MQTT authenticates devices; Event Grid uses its own MQTT broker with certificate or Entra ID-based auth.

Practice this question →
17
MCQeasy

Your organization requires that all messages sent to an Azure Service Bus Premium namespace are encrypted using customer-managed keys (CMK) stored in Azure Key Vault. Where must you configure this encryption setting?

A.At the Service Bus Namespace level
B.Inside the Event Grid subscription endpoint URI
C.At the individual Queue or Topic level
D.Within the Azure Function consumer application configuration
AnswerA

Customer-managed key encryption for Service Bus is configured on the namespace itself, where the Key Vault key and managed identity are referenced. Setting it at the namespace level applies the CMK to all queues and topics within that Premium namespace.

Why this answer

Customer-managed key (CMK) encryption for Azure Service Bus is configured at the namespace level, where you specify the Key Vault key and managed identity used to access it. This setting applies to all queues and topics within the namespace, ensuring data at rest is encrypted with your key. Namespace-level configuration is the only supported scope for CMK in Service Bus.

Exam trap

AI-200 often tests whether candidates think encryption can be scoped to individual queues or topics — remember Service Bus CMK is always namespace-level and requires Premium tier.

How to eliminate wrong answers

Option B is wrong because Event Grid subscription endpoint URIs are unrelated to Service Bus encryption; they define where events are delivered, not how Service Bus data is encrypted. Option C is wrong because Service Bus does not support per-queue or per-topic CMK configuration — encryption scope is namespace-wide. Option D is wrong because the consumer application configuration (e.g., Azure Function settings) controls client-side behavior, not the at-rest encryption of the Service Bus namespace.

Practice this question →
18
MCQeasy

You are designing an event-driven AI application that requires routing custom events from an Azure resource to multiple downstream serverless webhooks. Which Azure messaging service should you use to publish and route these events reliably?

A.Azure Service Bus
B.Azure Event Hubs
C.Azure Storage Queues
D.Azure Event Grid
AnswerD

Azure Event Grid is a publish-subscribe service built for event routing, delivering custom events from a source to multiple subscriber webhooks. Its native fan-out and retry handling satisfy the requirement to route events reliably to several downstream serverless endpoints.

Why this answer

Azure Event Grid is a fully managed event routing service designed for event-driven architectures. It natively supports custom events published to a topic, and can route them to multiple subscribers—including serverless webhooks—via event subscriptions. It provides reliable delivery with retries, dead-lettering, and filtering, making it the ideal choice for routing custom events to multiple downstream webhooks.

Exam trap

AI-200 often tests the confusion between Event Grid, Event Hubs, and Service Bus: candidates may incorrectly choose Service Bus because it supports topics and subscriptions, but Event Grid is the only service that natively pushes events to multiple webhooks with built-in filtering and retry.

How to eliminate wrong answers

Option A is wrong because Azure Service Bus is a message broker for enterprise messaging patterns (queues, topics with subscriptions) but it is not designed for lightweight event routing to webhooks; it requires consumers to poll or use the SDK, and does not natively push to HTTP endpoints without additional code. Option B is wrong because Azure Event Hubs is a big data streaming platform optimized for high-throughput telemetry ingestion, not for routing discrete custom events to multiple webhooks; it lacks native webhook push and event filtering. Option C is wrong because Azure Storage Queues is a simple queue service for asynchronous messaging between components, but it does not support publish-subscribe fan-out to multiple subscribers, nor does it push events to webhooks.

Practice this question →
19
MCQeasy

You are developing a serverless AI notification workflow. When an AI model finishes training, it publishes an event to an Azure Event Grid topic. You want to trigger an Azure Logic App when this event occurs. Which Event Grid subscription event delivery schema and endpoint type should you select?

A.Select 'Webhook' as the endpoint type and provide the Logic Apps HTTP Request URL.
B.Select 'Storage Queue' as the endpoint type.
C.Select 'Azure Service Bus Queue' as the endpoint type and provide the queue connection string.
D.Select 'Azure Event Hubs' as the endpoint type and provide the connection string.
AnswerA

Logic Apps exposes an HTTP Request trigger endpoint, so subscribing with endpoint type Webhook and supplying that URL lets Event Grid POST the model-training event directly into the workflow, satisfying the trigger requirement without extra relay components.

Why this answer

Azure Logic Apps expose an HTTP-triggered endpoint (the 'When an HTTP request is received' or Event Grid trigger URL) that Event Grid can invoke directly. Selecting 'Webhook' as the endpoint type and supplying the Logic App's HTTP Request URL lets Event Grid POST the event payload to the Logic App, which then parses it and runs the workflow. This is the standard, first-class integration pattern for Event Grid → Logic Apps.

Exam trap

AI-200 often tests whether candidates confuse Event Grid's push-based reactive notification model with Event Hubs' pull-based streaming model, leading them to pick Event Hubs as the endpoint type for a Logic App trigger.

How to eliminate wrong answers

Option B is wrong because a Storage Queue endpoint writes the event as a message into an Azure Storage Queue, which a Logic App would have to poll separately rather than being triggered reactively by the event. Option C is wrong because a Service Bus Queue endpoint delivers events into Service Bus for a Service Bus consumer to process — it does not directly trigger a Logic App and adds an unnecessary intermediary. Option D is wrong because Event Hubs is a high-throughput streaming ingestion service, not a discrete event notification endpoint, and it would not trigger a Logic App workflow on a single Event Grid event.

Practice this question →
20
MCQmedium

Your organization uses Azure Service Bus Topics. You need to ensure that messages published to a topic are delivered to subscriptions in a specific priority order (e.g., high priority messages processed before normal priority). What is the recommended Service Bus design pattern to achieve this?

A.Create separate queues or subscriptions for high-priority and normal-priority messages, and have workers poll the high-priority entity first.
B.Set the Priority property on the Service Bus message header to 99.
C.Configure Event Hubs partition key hashing to group priority messages.
D.Enable Event Grid priority filters on the topic.
AnswerA

Service Bus cannot reorder messages by priority within a single subscription, so separate entities per priority level let workers drain the high-priority queue first. This satisfies the stem's requirement for priority-ordered processing, since competing consumers on one entity would not guarantee ordering.

Why this answer

Service Bus does not natively support message priority ordering, so the recommended pattern is to create separate queues or subscriptions for each priority level and have consumers drain the high-priority entity first. This gives deterministic priority handling because the broker processes each entity independently and the consumer controls polling order. It is the standard workaround for the absence of a built-in priority property.

Exam trap

AI-200 often tests whether candidates invent a non-existent 'Priority' property on Service Bus messages — the correct answer is always the separate-entity pattern because Service Bus has no native priority field.

How to eliminate wrong answers

Option B is wrong because Service Bus does not expose a settable Priority property on message headers — this is a fictional feature; AMQP has no standard priority field honored by Service Bus. Option C is wrong because Event Hubs partition key hashing is unrelated to Service Bus topics and does not provide priority ordering. Option D is wrong because Event Grid priority filters do not exist — Event Grid supports subject/event-type filters, not priority-based routing.

Practice this question →
21
MCQhard

You are designing an enterprise AI event-driven pipeline. Events from multiple SaaS applications are published to an Azure Event Grid domain. You need to ensure that a rogue tenant cannot exhaust the delivery throughput of other tenants. Which feature should you leverage?

A.Deploy separate Event Grid topics or distinct Event Domains per tenant with dedicated custom access keys or managed identities.
B.Set the maximum delivery retry count to zero for all tenants.
C.Enable Azure DDoS Protection Standard on the storage account dead-letter container.
D.Configure Service Bus partitioned queues in front of the Event Grid domain.
AnswerA

Event Grid applies throttling per topic or domain, so a noisy tenant sharing one domain consumes the shared quota. Isolating tenants into separate topics or domains with dedicated keys or managed identities confines each tenant's throughput, preventing one rogue publisher from starving others.

Why this answer

Deploying separate Event Grid topics or distinct Event Domains per tenant with dedicated access keys or managed identities isolates each tenant's publishing and delivery throughput, preventing a rogue tenant from exhausting shared resources. Event Grid domains allow multi-tenant publishing with per-tenant topics, but true throughput isolation requires separate domains or topics with separate authentication and quotas. This design ensures noisy-neighbor effects are contained.

Exam trap

The trap is thinking that retry settings or DDoS protection solve tenant throughput isolation; candidates must recognize that Event Grid throughput is a shared resource and only separate topics/domains with dedicated authentication provide isolation.

How to eliminate wrong answers

Option B is wrong because setting maximum delivery retry count to zero does not isolate throughput; it only affects retry behavior and could cause event loss, not prevent one tenant from consuming shared capacity. Option C is wrong because Azure DDoS Protection Standard protects against network-layer attacks on public IPs; it does not address Event Grid delivery throughput contention among tenants. Option D is wrong because Service Bus partitioned queues in front of Event Grid do not isolate Event Grid publishing throughput; they add a buffering layer but the Event Grid domain remains a shared resource subject to tenant contention.

Practice this question →
22
MCQeasy

Your application publishes events to an Azure Event Grid topic. You want to ensure that event publishers must present a valid shared access signature or key in the HTTP request header. Which header name does Event Grid expect for key-based authentication?

A.aeg-sas-key
B.Authorization
C.x-functions-key
D.sb-connection-string
AnswerA

Event Grid accepts key-based publisher authentication through the aeg-sas-key request header, which carries the topic or domain access key. Supplying that header satisfies the stem's requirement that publishers present a valid key in the HTTP request.

Why this answer

Azure Event Grid accepts key-based authentication via the 'aeg-sas-key' HTTP header, which carries the topic or domain access key. Publishers include this header to authenticate without needing an Azure AD token, and Event Grid validates it against the topic's configured keys.

Exam trap

The trap is defaulting to the generic 'Authorization' header because it is the most familiar authentication header — candidates overlook that Event Grid's key-based scheme uses a service-specific header name, aeg-sas-key.

How to eliminate wrong answers

Option B is wrong because 'Authorization' is the standard header for bearer tokens (Azure AD / OAuth 2.0), not for Event Grid's key-based scheme. Option C is wrong because 'x-functions-key' is used by Azure Functions HTTP triggers for function-level or host-level key authentication, not by Event Grid. Option D is wrong because 'sb-connection-string' is not an HTTP header at all — it is a Service Bus connection string used in SDK configuration, and Service Bus is a different service.

Practice this question →
23
MCQhard

You are implementing an AI model training pipeline that uses Azure Event Hubs to ingest training data. The pipeline must process data in order per partition and maintain high throughput. You are using the EventProcessorClient in a .NET application. You notice that some partitions are lagging while others are idle. You need to optimize the processor to balance the load across partitions. What should you do?

A.Configure the EventProcessorClient to use a higher prefetch count.
B.Ensure that the number of EventProcessorClient instances matches the number of partitions and that they are using the same consumer group.
C.Increase the number of partitions in the Event Hub.
D.Use a different consumer group for each partition to isolate processing.
AnswerB

EventProcessorClient instances within the same consumer group coordinate to distribute partitions evenly. If there are fewer instances than partitions, some instances will own multiple partitions, leading to potential lag. If there are more instances than partitions, some instances will be idle. To balance load, the number of instances should match the number of partitions, and they must use the same consumer group to coordinate ownership.

Why this answer

EventProcessorClient instances in the same consumer group use partition ownership to distribute partitions among themselves. For optimal load balancing, the number of instances should equal the number of partitions. If there are fewer instances, some instances handle multiple partitions and may lag.

If more, some instances are idle. Ensuring the instance count matches the partition count and that all instances use the same consumer group allows the processor to evenly distribute partitions.

Exam trap

The trap here is thinking that increasing prefetch count or partitions will solve load balancing, when the real issue is the mismatch between the number of processor instances and partitions.

Practice this question →
24
MCQmedium

You are building an AI financial transactions ledger using Azure Service Bus. Each transaction must be processed strictly in order per account ID, and if a transaction fails, subsequent transactions for that specific account must wait until the issue is resolved. Which feature should you use?

A.Event Hubs partitions with round-robin load balancing
B.Service Bus Sessions (SessionId set to the account ID)
C.Azure Storage Queues with invisible timeout properties
D.Event Grid advanced filters keyed by account ID
AnswerB

Sessions bind messages sharing a SessionId to a single ordered receiver, guaranteeing FIFO delivery per account ID. A failed transaction blocks that session's remaining messages until resolved, while other accounts continue unaffected, meeting the per-account ordering constraint.

Why this answer

Service Bus Sessions provide FIFO ordering guarantees per SessionId, and setting SessionId to the account ID ensures all transactions for a given account are processed sequentially by a single receiver. Sessions also enable the receiver to lock the session, so if a transaction fails, subsequent messages in that session are not delivered until the lock is released or the message is completed/abandoned. This satisfies both the strict per-account ordering and the blocking-on-failure requirement.

Exam trap

AI-200 often tests the misconception that Event Hubs partitions or Storage Queues provide per-key ordering and blocking; candidates confuse partition-level ordering with session-level FIFO and forget that only Service Bus Sessions offer an exclusive lock that halts subsequent messages for a given key.

How to eliminate wrong answers

Option A is wrong because Event Hubs partitions provide ordering only within a partition, and round-robin load balancing actively distributes messages across partitions, breaking per-account ordering; Event Hubs also lacks per-message session locking semantics. Option C is wrong because Azure Storage Queues offer no ordering guarantee and the invisible timeout only hides a message during processing—it does not serialize processing per account or block subsequent messages. Option D is wrong because Event Grid advanced filters only route events based on payload attributes; Event Grid is a push-based pub/sub service with at-least-once delivery and no ordering or session semantics, so it cannot enforce sequential processing or blocking.

Practice this question →
25
MCQmedium

Your enterprise application uses Azure Service Bus Topics to distribute orders to inventory and billing services. A transient database outage occurs in the billing service. You must ensure that billing messages are not lost and can be retried without interfering with the inventory service. What feature should you configure?

A.Enable partitioned queues on the sender application.
B.Use Event Grid filters to duplicate the messages into two separate storage accounts.
C.Configure separate subscriptions for each service under the Service Bus Topic.
D.Implement Azure Relay to tunnel the database connection.
AnswerC

Separate subscriptions give each service an independent copy of every order message, so the billing subscription retains messages during its database outage while inventory continues processing unaffected. This satisfies the stem's isolation requirement, which a shared subscription with competing consumers could not.

Why this answer

Configuring separate subscriptions for each service under the Service Bus Topic is correct because each subscription receives its own copy of the message, allowing the billing service to process independently and retry on failure without affecting the inventory service. This provides isolation and ensures messages are not lost during transient outages. Other options do not provide the required decoupling and retry capability.

Exam trap

AI-200 often tests the misconception that a single queue or topic without subscriptions can serve multiple services, but the correct pattern is separate subscriptions for isolation and retry.

How to eliminate wrong answers

Option A is wrong because partitioned queues are for scaling and throughput, not for isolating services; they do not duplicate messages to multiple consumers. Option B is wrong because Event Grid filters are for routing events, not for duplicating Service Bus messages into storage accounts; this would not provide the necessary retry mechanism for the billing service. Option D is wrong because Azure Relay is for exposing on-premises services, not for message distribution or retry logic in Service Bus.

Practice this question →
26
MCQhard

You are designing an AI streaming architecture using Azure Event Hubs in a Dedicated cluster. You need to monitor capacity utilization to ensure the cluster does not exceed its allocated Processing Units (PUs). Which metric should you track in Azure Monitor?

A.Service Bus Active Message Count.
B.Event Grid Delivery Success Rate percentage.
C.Dedicated Cluster Memory and CPU Usage / Processing Units (PUs) Utilization metrics.
D.Storage Account Blob Capacity utilization.
AnswerC

Tracking Processing Units (PU) utilisation directly reports consumption against the Dedicated cluster's allocated capacity, which is the constraint the stem specifies. Memory and CPU metrics describe resource pressure within nodes but cannot express PU headroom, so they fail to confirm whether the cluster remains within its provisioned limit.

Why this answer

In an Azure Event Hubs Dedicated cluster, capacity is measured and billed in Processing Units (PUs), and the cluster exposes specific Azure Monitor metrics for CPU, memory, and PU utilization. Tracking 'Processing Units (PUs) Utilization' (alongside CPU and Memory usage) is the direct way to see whether the cluster is approaching its allocated PU ceiling. These metrics are emitted per cluster under the Microsoft.EventHub/clusters namespace, so they are the authoritative signal for capacity planning.

Exam trap

AI-200 often tests whether candidates confuse Event Hubs Dedicated capacity metrics (PU/CU utilization) with unrelated service metrics like Service Bus message counts or Event Grid delivery rates.

How to eliminate wrong answers

Option A is wrong because Service Bus Active Message Count is a Service Bus namespace metric and has nothing to do with Event Hubs Dedicated cluster capacity. Option B is wrong because Event Grid Delivery Success Rate measures event delivery reliability in Event Grid, not Event Hubs throughput or PU consumption. Option D is wrong because Storage Account Blob Capacity tracks blob storage consumption, which is unrelated to Event Hubs compute capacity.

Practice this question →
27
MCQhard

Your Azure Service Bus Premium namespace hosts critical AI request queues. Due to sudden spikes in inference requests, one of the queues experiences peak concurrency exceeding the maximum throughput units. You need to scale the namespace capacity automatically without manual intervention. What feature should you configure?

A.Configure geo-disaster recovery pairing with an active-active replication policy.
B.Enable Partitioning on the Service Bus queue entities.
C.Configure Azure Functions Premium plan scaling triggers based on Service Bus queue length.
D.Enable Auto-inflate on the Service Bus namespace and specify the maximum messaging units.
AnswerD

Auto-inflate dynamically raises the namespace's messaging units when throttling occurs, then scales back down once load subsides, satisfying the requirement for automatic scaling without manual intervention. Setting the maximum messaging units caps that growth, preventing runaway cost while absorbing the inference-request spikes that exceed current throughput.

Why this answer

Auto-inflate is the native Azure Service Bus Premium feature that automatically scales messaging units (throughput capacity) when the namespace approaches its limits, up to a configured maximum. It requires Premium tier and operates without manual intervention, making it the correct answer for handling sudden concurrency spikes on critical queues.

Exam trap

AI-200 often tests whether candidates confuse consumer-side scaling (Functions, KEDA) with broker-side capacity scaling (auto-inflate), and whether they know which features are Premium-only.

How to eliminate wrong answers

Option A is wrong because geo-disaster recovery provides regional failover for availability, not throughput scaling — it does not increase capacity within a namespace. Option B is wrong because partitioning divides a queue across multiple message brokers for throughput and availability, but it does not dynamically scale namespace-level capacity and is available in Standard tier as well. Option C is wrong because Azure Functions Premium plan scaling adjusts the number of function instances consuming messages, not the Service Bus namespace's throughput units — it addresses consumer-side scaling, not broker-side capacity.

Practice this question →
28
MCQhard

You are designing an enterprise event-driven architecture where microservices across different Azure subscriptions need to subscribe to domain events published by a central Order Service. Which Azure Event Grid architecture should you implement?

A.Deploy an Azure Service Bus relay across all subscriptions.
B.Deploy an Azure Event Grid Event Domain and create event subscriptions under the domain for each consuming team.
C.Create individual Event Hubs namespaces in every consumer subscription and peer them via ExpressRoute.
D.Use Azure Storage Queues shared via SAS URLs across subscriptions.
AnswerB

Event Domains provide a single management and publishing endpoint that thousands of topics can share, letting each consuming team create its own subscriptions across subscriptions. This satisfies the cross-subscription, multi-team fan-out constraint without deploying a separate topic per consumer.

Why this answer

Azure Event Grid Event Domains are purpose-built for multi-tenant, multi-subscription event distribution scenarios. An Event Domain acts as a namespace that can host thousands of topics, allowing each consuming team or subscription to create its own event subscriptions under the domain without the publisher needing to manage individual topics per consumer. This decouples the central Order Service from consumer onboarding and scales cleanly across subscriptions.

Exam trap

AI-200 often tests the distinction between Event Grid (discrete event routing/pub-sub), Event Hubs (streaming telemetry ingestion), and Service Bus (enterprise messaging with ordering/transactions) — candidates confuse these three services and pick the wrong one for the fan-out scenario.

How to eliminate wrong answers

Option A is wrong because Service Bus is a message broker with queues/topics designed for point-to-point or pub/sub messaging with ordering guarantees, not for fan-out event routing across many independent subscribers in different subscriptions. Option C is wrong because Event Hubs is a high-throughput streaming ingestion service, not an event routing fabric, and ExpressRoute peering is a network connectivity mechanism unrelated to event subscription management. Option D is wrong because Storage Queues are simple point-to-point message queues with no native pub/sub fan-out, and sharing SAS URLs does not provide event subscription semantics or cross-subscription routing.

Practice this question →
29
Multi-Selecthard

Your team is comparing Azure Event Grid, Event Hubs, and Service Bus for an AI platform integration project. Which THREE statements correctly contrast these services? Each correct answer is factually accurate.

Select 3 answers
A.Event Hubs provides native webhook push delivery for serverless triggers without consumer code.
B.Event Grid is optimized for pub/sub discrete event notifications with push delivery.
C.Event Hubs is optimized for high-throughput big data streaming and telemetry ingestion.
D.Event Grid supports AMQP 1.0 session-based strict FIFO message ordering.
E.Service Bus is designed for enterprise messaging supporting transactions, sessions, and dead-lettering.
AnswersB, C, E

Event Grid's push delivery dispatches discrete event notifications to subscribers via pub/sub, matching the contrast required against Event Hubs' streaming pull model and Service Bus's brokered enterprise messaging. This discrete, reactive notification pattern is the axis distinguishing it from high-throughput telemetry ingestion.

Why this answer

Option B is correct because Event Grid is purpose-built for reactive, discrete-event pub/sub scenarios and pushes events to subscribers via webhooks or Azure service handlers, making it ideal for serverless triggers. Option C is correct because Event Hubs is a big-data streaming platform engineered for high-throughput telemetry and event ingestion (millions of events per second) with partitioned consumer groups and retention, not discrete notification routing. Option E is correct because Service Bus is the enterprise brokered-messaging service offering transactions, sessions for strict FIFO ordering, dead-lettering, duplicate detection, and scheduled delivery.

Option A is wrong because native webhook push delivery for serverless triggers is an Event Grid capability, not Event Hubs, which requires consumers to pull from partitions (or use the Kafka/AMQP endpoints). Option D is wrong because AMQP 1.0 session-based strict FIFO ordering is a Service Bus feature, not Event Grid, which delivers discrete events with at-least-once semantics and no ordering guarantees.

Exam trap

AI-200 often tests the push-vs-pull confusion — candidates assume Event Hubs pushes to webhooks like Event Grid, but Event Hubs is pull-based and only Event Grid offers native webhook push.

Practice this question →
30
MCQeasy

Your application publishes events to an Azure Event Grid system topic. You want to filter events so that your webhook subscriber receives only events where the 'eventType' is 'Microsoft.Storage.BlobCreated'. Where should you configure this filter?

A.Within the Azure Function host.json configuration file.
B.In the Service Bus Topic subscription SQL filter.
C.Inside the Azure Storage account connection string settings.
D.In the Event Grid subscription filter configuration blade under 'Included Event Types'.
AnswerD

Included Event Types filtering operates at the subscription level, letting the webhook receive only Microsoft.Storage.BlobCreated events. Configuring this on the Event Grid subscription satisfies the stem's requirement to restrict delivery by eventType before events reach the subscriber endpoint.

Why this answer

Event filtering for Azure Event Grid is configured on the Event Grid subscription itself, not in the subscriber or the event source. The 'Included Event Types' setting in the Event Grid subscription filter configuration blade lets you specify which event types (such as 'Microsoft.Storage.BlobCreated') are delivered to the subscriber endpoint. This filter is evaluated by Event Grid before the event is pushed to the webhook, so only matching events reach the subscriber.

Exam trap

AI-200 often tests the misconception that filtering can be configured at the subscriber (e.g., in host.json or code) or at the source (e.g., storage connection string), when in fact Event Grid filtering is configured on the Event Grid subscription resource itself.

How to eliminate wrong answers

Option A is wrong because the Azure Function host.json file configures the Functions runtime (e.g., logging, extensions, function timeout), not Event Grid event filtering; Event Grid filtering happens before the event ever reaches the function. Option B is wrong because Service Bus Topic subscription SQL filters apply to Service Bus messages, not Event Grid events, and Event Grid does not use Service Bus SQL filter syntax. Option C is wrong because the Azure Storage account connection string contains authentication and endpoint information for accessing storage, not event filtering rules for Event Grid subscriptions.

Practice this question →
31
MCQhard

You are designing an asynchronous AI transaction pipeline using Azure Service Bus. You need to implement the Competing Consumers pattern where multiple worker instances process messages from a single queue without duplicating work. How does Azure Service Bus natively support this pattern?

A.Configure Event Hubs consumer groups with exclusive read locks.
B.You must write custom distributed locking logic using Azure Blob Leases in front of the queue.
C.Service Bus automatically locks and distributes messages across competing workers using PeekLock mode.
D.You must deploy an Event Grid topic with a round-robin webhook load balancer.
AnswerC

PeekLock lets each worker lock a message, making it invisible to other consumers while processing, then complete or abandon it. Service Bus thus distributes each message to exactly one competing worker, preventing duplicate processing without custom coordination.

Why this answer

Azure Service Bus natively implements the Competing Consumers pattern through PeekLock receive mode: each worker receives a message, obtains an exclusive lock token, and other workers cannot see that message until the lock expires or is released. This broker-side locking distributes messages across competing workers without duplicate processing, as long as handlers settle messages within the lock duration.

Exam trap

AI-200 often tests whether candidates recognize that Service Bus provides competing-consumer locking natively via PeekLock, versus assuming they must build custom distributed locking or use Event Hubs consumer groups.

How to eliminate wrong answers

Option A is wrong because Event Hubs consumer groups are for partitioned streaming reads and do not provide exclusive per-message locks — multiple consumers in the same group can read the same partition offsets. Option B is wrong because Service Bus already provides broker-side locking; adding Blob Leases would be redundant custom coordination. Option D is wrong because Event Grid is a push-based event routing service with webhook delivery, not a queue with competing consumer semantics or round-robin load balancing.

Practice this question →
32
MCQhard

You are deploying an enterprise AI text-analysis system using Azure Service Bus topics and subscriptions. Downstream processing requires strict message ordering and session-aware processing so that related conversational turns are processed sequentially by the same worker instance. Which property must you enable on the Service Bus subscription?

A.Enable Sessions on the subscription and group messages using a Session ID.
B.Enable Partitioning on the topic.
C.Set Duplicate Detection with a time window.
D.Configure Dead-lettering on message expiration.
AnswerA

Sessions guarantee FIFO delivery and exclusive, ordered processing by a single worker instance, satisfying the sequential conversational-turn constraint. Messages sharing a Session ID are locked to one receiver, preventing concurrent handlers from reordering related turns across competing consumers.

Why this answer

Enabling sessions on the subscription is the only way to guarantee FIFO (first-in, first-out) ordering and affinity between related messages and a single processing instance. When a message is sent with a SessionId, Service Bus ensures that all messages with the same SessionId are delivered in order to the same receiver that holds the session lock. This directly satisfies the requirement that related conversational turns are processed sequentially by the same worker instance.

Exam trap

AI-200 often tests the misconception that partitioning or duplicate detection can provide ordering, when in fact only sessions guarantee FIFO and session affinity.

How to eliminate wrong answers

Option B is wrong because partitioning on the topic improves throughput and availability by spreading messages across multiple brokers, but it does not guarantee ordering or session affinity; in fact, partitioning can break ordering if not used with sessions. Option C is wrong because duplicate detection only prevents duplicate messages within a specified time window; it has no effect on ordering or session-aware processing. Option D is wrong because dead-lettering on message expiration moves expired messages to a dead-letter queue for later inspection; it does not provide ordering or session affinity.

Practice this question →
33
MCQmedium

You are managing an Azure Service Bus Standard namespace. Your development team requests the ability to use Topics and Subscriptions. What action must you take to support this requirement?

A.Enable AMQP 1.0 multiplexing on the Basic tier namespace.
B.Create an Event Hubs capture rule to simulate topic subscriptions.
C.Ensure the Service Bus namespace is at the Standard or Premium tier.
D.Upgrade the namespace to Azure Event Grid Premium.
AnswerC

Topics and Subscriptions are unavailable on the Basic tier; they require Standard or Premium. The namespace is already Standard, so no tier change is needed. Premium adds isolation and predictable performance but is not required for this functionality.

Why this answer

Azure Service Bus Topics and Subscriptions are only available in the Standard and Premium tiers. The Basic tier does not support topics; it only supports queues. Therefore, to use Topics and Subscriptions, the namespace must be at the Standard or Premium tier.

Exam trap

AI-200 often tests the feature limitations of Service Bus tiers; candidates may incorrectly believe that Basic tier supports topics or that upgrading to Event Grid provides similar functionality.

How to eliminate wrong answers

Option A is wrong because AMQP 1.0 multiplexing is a feature of the Basic tier, but it does not enable Topics and Subscriptions; the Basic tier fundamentally lacks support for topics. Option B is wrong because Event Hubs capture rules are unrelated to Service Bus and cannot simulate topic subscriptions; Event Hubs is a different service. Option D is wrong because Azure Event Grid Premium is a different service for event routing, not a tier of Service Bus, and upgrading to it does not provide Service Bus topics.

Practice this question →
34
MCQhard

You are optimizing an Azure Event Hubs stream processing application in Python. Messages are being processed too slowly, and you notice high CPU utilization on the consumer instance due to synchronous network I/O. Which programming model should you adopt to maximize ingestion throughput?

A.Increase the partition count of the Event Hub to 1,000 partitions.
B.Switch from Event Hubs to Azure Storage Queues for parallel processing.
C.Migrate all consumer code to use synchronous REST API polling over HTTPS GET requests.
D.Use the asynchronous Event Hub client library (`azure-eventhub.aio`) with `asyncio` for non-blocking I/O operations.
AnswerD

Adopting `azure-eventhub.aio` with `asyncio` replaces blocking synchronous network calls with non-blocking coroutines, so the consumer can overlap I/O waits with message processing instead of idling on each receive. This directly relieves the high CPU utilisation caused by synchronous I/O, maximising ingestion throughput across partitions.

Why this answer

The azure-eventhub.aio library exposes an async client built on asyncio, allowing the consumer to await network I/O (receiving events, checkpointing) without blocking the event loop. This eliminates the CPU waste caused by synchronous blocking calls and lets a single instance handle many concurrent partition receivers, maximizing throughput.

Exam trap

AI-200 often tests async vs sync SDK selection — candidates pick 'more partitions' or 'different service' when the actual bottleneck is blocking I/O, and the fix is the asyncio-based azure-eventhub.aio client.

How to eliminate wrong answers

Option A is wrong because Event Hubs supports a maximum of 32 partitions per event hub in Standard and 32–1024 in Premium/Dedicated depending on throughput units, and 1,000 partitions is not a supported configuration for the standard tier — more importantly, partition count is fixed at creation and does not address CPU-bound synchronous I/O. Option B is wrong because Azure Storage Queues are not a streaming log, lack partitioning and replay, and are not a throughput upgrade for Event Hubs workloads. Option C is wrong because synchronous REST polling over HTTPS GET is even more blocking and less efficient than the AMQP SDK — it would worsen CPU utilization, not improve it.

Practice this question →
35
MCQhard

You are designing an AI streaming pipeline using Azure Event Hubs. You need to inspect diagnostic logs and operational metrics to track incoming request rates, server errors, and throttling events across the namespace. Where should you configure this telemetry collection in the Azure Portal?

A.Diagnostic Settings on the Event Hubs namespace pointing to a Log Analytics workspace.
B.Event Hubs Capture export storage container settings.
C.Azure Bastion diagnostic configuration.
D.Auto-Inflate throughput unit configuration blade.
AnswerA

Diagnostic Settings on the namespace route platform metrics and resource logs to a Log Analytics workspace, where request rates, server errors and throttling can be queried. Namespace-level scope captures telemetry across all hubs and consumer groups, satisfying the cross-namespace visibility the scenario requires.

Why this answer

Diagnostic Settings on the Event Hubs namespace is the correct place to route platform logs (including operational/diagnostic logs) and metrics to destinations like Log Analytics, Storage, or Event Hubs. This is where you enable collection of request rates, server errors, and throttling events for the namespace. It is the standard Azure Monitor integration point for resource-level telemetry.

Exam trap

AI-200 often tests the distinction between data-plane features (Capture, Auto-Inflate) and control-plane telemetry (Diagnostic Settings) — candidates mistakenly pick Capture or Auto-Inflate thinking they provide monitoring, when only Diagnostic Settings routes logs and metrics.

How to eliminate wrong answers

Option B is wrong because Event Hubs Capture is a data-plane feature that exports streaming event payloads to Storage/Data Lake in Avro format — it does not collect diagnostic logs or operational metrics. Option C is wrong because Azure Bastion is a secure RDP/SSH jump-host service with no relationship to Event Hubs telemetry. Option D is wrong because Auto-Inflate is a throughput scaling feature that automatically increases throughput units; it does not provide log or metric collection, though it may generate throttling-related events that are only visible via Diagnostic Settings.

Practice this question →
36
MCQeasy

You are building an event-driven AI workflow where an Azure Event Grid event triggers an Azure Function. To ensure that the function handles the Event Grid handshake validation handshake correctly when the subscription is created, what must your function code include?

A.An Event Hubs consumer group checkpoint store configuration.
B.A Service Bus session lock renewal loop.
C.Code to handle the SubscriptionValidationEvent and return the validation code.
D.An AMQP listener connection string.
AnswerC

Event Grid sends a SubscriptionValidationEvent during subscription creation, and the function must return the validation code from that payload so Event Grid confirms the endpoint. Without this handshake handling, the subscription stays unvalidated and events are never delivered.

Why this answer

When Event Grid creates a webhook subscription, it sends a SubscriptionValidationEvent to the endpoint. The function must detect this event type, extract the validationCode from the event data, and return it in the HTTP response so Event Grid can confirm endpoint ownership. Without this handshake handling, the subscription creation fails and events are never delivered.

Exam trap

AI-200 often tests whether candidates know that Event Grid requires an explicit SubscriptionValidationEvent response, confusing it with other messaging services that do not perform endpoint ownership validation.

How to eliminate wrong answers

Option A is wrong because an Event Hubs consumer group checkpoint store is used for offset management in Event Hubs streaming, not for Event Grid subscription validation. Option B is wrong because Service Bus session lock renewal is a Service Bus concept for maintaining session ownership, unrelated to Event Grid's validation handshake. Option D is wrong because an AMQP listener connection string is used for AMQP-based messaging protocols (Service Bus, Event Hubs), not for the HTTP-based Event Grid validation handshake.

Practice this question →
37
MCQeasy

Your application publishes events to an Azure Event Grid custom topic. You need to inspect the operational health and delivery success metrics of your event subscriptions. Where should you view these metrics natively in the Azure Portal?

A.The Metrics blade of the Event Grid Topic or Domain in the Azure Portal
B.The Azure Storage Account Access Logs
C.The Service Bus Explorer tool
D.The App Service Kudu diagnostic console
AnswerA

The Metrics blade on the Event Grid topic or domain exposes native platform metrics, including publish and delivery success, failure, and dropped event counts, broken down by subscription. This directly satisfies the requirement to inspect operational health and delivery success of your event subscriptions without extra tooling.

Why this answer

Azure Event Grid exposes native platform metrics on the Event Grid Topic or Domain resource itself, including publish/delivery success, matched/attempted/dropped events, and delivery latency. These are surfaced under the Metrics blade of the topic or domain in the Azure Portal, where you can chart and alert on them. This is the built-in operational health view for event subscriptions without needing external tooling.

Exam trap

The trap here is confusing Event Grid with Service Bus or Storage — candidates pick Service Bus Explorer or Storage logs because those tools also deal with messaging, but only the Event Grid Topic/Domain Metrics blade exposes native delivery health.

How to eliminate wrong answers

Option B is wrong because Azure Storage Account Access Logs record blob/queue/table operations, not Event Grid subscription delivery telemetry. Option C is wrong because Service Bus Explorer is a third-party/community tool for inspecting Service Bus queues, topics, and subscriptions — it has no visibility into Event Grid topics or subscriptions. Option D is wrong because the App Service Kudu diagnostic console is a web-based deployment and process diagnostic tool for App Service, not a metrics surface for Event Grid.

Practice this question →
38
MCQmedium

You are building an event-driven application where messages sent to an Azure Service Bus queue must not be processed until a specific date and time in the future (e.g., 2 hours from now). What property should you set on the outgoing message?

A.TimeToLive
B.LockDuration
C.ScheduledEnqueueTimeUtc
D.SequenceNumber
AnswerC

ScheduledEnqueueTimeUtc defers message availability until the specified UTC timestamp; the queue holds the message invisibly and only releases it for processing at that moment, satisfying the requirement that messages wait until a future date and time.

Why this answer

ScheduledEnqueueTimeUtc is the Service Bus message property that defers a message's visibility in the queue until a specified UTC timestamp. Setting it to two hours in the future means the broker holds the message and only makes it available to receivers after that time, exactly matching the delayed-processing requirement. This is the native, broker-side scheduling mechanism for Service Bus.

Exam trap

The trap here is confusing TimeToLive (message expiry) with ScheduledEnqueueTimeUtc (delayed visibility) — candidates often pick TTL thinking it delays delivery, when it actually controls how long the message survives in the queue.

How to eliminate wrong answers

Option A is wrong because TimeToLive controls how long a message remains in the queue before expiring and being dead-lettered — it does not delay initial visibility. Option B is wrong because LockDuration is the peek-lock period a receiver holds a message before it must be completed or abandoned; it governs processing time, not scheduling. Option D is wrong because SequenceNumber is a broker-assigned read-only identifier used for ordering and deduplication, not a settable scheduling control.

Practice this question →
39
MCQeasy

You are developing a serverless application using Azure Functions that reacts to Azure Blob Storage creation events. Which event schema format should your function code expect by default when triggered by an Event Grid subscription?

A.Azure Event Grid schema
B.Apache Kafka record batch schema
C.AMQP 1.0 message envelope
D.SOAP XML envelope
AnswerA

Blob Storage creation events delivered through an Event Grid subscription arrive in the Azure Event Grid schema by default, so the function must deserialise that envelope's eventType, subject and data fields unless CloudEvents is explicitly selected.

Why this answer

Azure Functions triggered by an Event Grid subscription receive events in the Azure Event Grid schema by default. This schema includes fields like `id`, `subject`, `data`, `eventType`, `eventTime`, and `dataVersion`, with the actual blob details nested under `data`. The function code must deserialize this JSON structure to access properties such as the blob URL.

No additional configuration is needed to use this default schema.

Exam trap

AI-200 often tests the confusion between Event Grid schema and CloudEvents schema, or between Event Grid and other messaging services like Event Hubs (which uses AMQP) or Kafka, leading candidates to select a non-default or incorrect protocol format.

How to eliminate wrong answers

Option B is wrong because Apache Kafka record batch schema is used for Kafka topics, not for Event Grid subscriptions; Event Grid does not natively produce Kafka-formatted batches. Option C is wrong because AMQP 1.0 message envelope is the protocol format used by Azure Service Bus and Event Hubs (when using AMQP), not by Event Grid events delivered to Functions. Option D is wrong because SOAP XML envelope is a legacy web service protocol and is not used by Event Grid, which delivers events as JSON.

Practice this question →
40
MCQhard

You are implementing distributed tracing across an event-driven AI workflow that passes messages from Azure Service Bus to Azure Functions, and finally to an Azure Cosmos DB database. Which mechanism should you use to propagate correlation context between these services?

A.Enabling Azure Monitor diagnostic logs on the storage account.
B.Using AMQP 1.0 session locks to lock the trace state across network boundaries.
C.W3C Trace Context standard HTTP headers (such as traceparent) propagated through Service Bus message user properties.
D.Custom GUID generation stored exclusively in the Event Grid event subject field.
AnswerC

W3C Trace Context headers carry the traceparent identifier, but Service Bus does not transmit HTTP headers natively. Propagating traceparent through message user properties preserves the correlation context across the asynchronous Service Bus hop, letting Azure Functions and Cosmos DB continue the same distributed trace.

Why this answer

Distributed tracing across Azure services relies on the W3C Trace Context standard, which defines headers like traceparent and tracestate to propagate correlation IDs. In Service Bus, these can be carried in message user properties (application properties) so that downstream services like Azure Functions and Cosmos DB can continue the trace. This enables end-to-end visibility in Application Insights.

Exam trap

AI-200 often tests the confusion between tracing mechanisms and message delivery features, such as session locks or diagnostic logs, which do not propagate correlation context.

How to eliminate wrong answers

Option A is wrong because Azure Monitor diagnostic logs on a storage account are unrelated to tracing event-driven workflows and do not propagate correlation context. Option B is wrong because AMQP 1.0 session locks are for ordered message delivery, not for trace state propagation. Option D is wrong because custom GUIDs stored only in the Event Grid event subject field are not a standard mechanism and would not be automatically propagated or recognized by tracing tools.

Practice this question →
41
MCQeasy

You are building an event-driven workflow where an external partner application needs to send custom events to your Azure backend. You decide to use Azure Event Grid Custom Topics. When the partner publishes an event, which event schema format must the JSON payload adhere to?

A.OData v4 batch request format
B.SOAP 1.2 XML envelope format
C.CloudEvents v1.0 schema or Event Grid schema
D.AMQP 1.0 message format exclusively
AnswerC

Event Grid custom topics accept either the proprietary Event Grid schema or the industry-standard CloudEvents v1.0 schema, selected when publishing. Both are valid JSON payload formats, so the partner application can submit events using whichever schema its publisher already supports without transformation.

Why this answer

Azure Event Grid custom topics accept events in either the proprietary Event Grid schema or the CloudEvents v1.0 schema; both are valid JSON formats for publishing custom events. The partner must serialize the event payload according to one of these schemas, and the topic's input schema setting determines which one is expected. This ensures interoperability with CloudEvents-compliant systems while retaining the native Event Grid format for Azure-centric integrations.

Exam trap

The trap is assuming Event Grid only accepts its proprietary schema; candidates may not know that CloudEvents v1.0 is also supported, or they may confuse the transport protocol (HTTP/AMQP) with the event schema (JSON structure).

How to eliminate wrong answers

Option A is wrong because OData v4 batch request format is an OData protocol construct for REST APIs, not an event schema; Event Grid does not parse OData batches. Option B is wrong because SOAP 1.2 XML envelope format is a legacy web services protocol; Event Grid requires JSON payloads and does not accept SOAP envelopes. Option D is wrong because AMQP 1.0 is a messaging protocol used by Service Bus and Event Hubs, not an event schema; Event Grid publishes over HTTP/HTTPS with JSON, not AMQP message format.

Practice this question →
42
Multi-Selectmedium

Your enterprise system uses Azure Service Bus. Which TWO mechanisms can you implement to handle 'poison' or repeatedly failing messages? (Choose two)

Select 2 answers
A.Configuring Auto-Inflate on the Service Bus namespace
B.Enabling Event Grid advanced filters on the queue
C.Setting the Partition Key to a null value
D.Configuring Max Delivery Count and automatic dead-lettering
E.Explicitly calling DeadLetterMessageAsync() in application code upon processing failure
AnswersD, E

Max Delivery Count caps redelivery attempts; once a message exceeds the threshold, Service Bus automatically moves it to the dead-letter queue. This removes the poison message from the active queue so it stops blocking processing.

Why this answer

Option D is correct because Service Bus queues and subscriptions have a MaxDeliveryCount property (default 10); once a message's delivery count exceeds this value, the broker automatically moves it to the dead-letter queue ($DeadLetterQueue), which is the built-in mechanism for isolating poison messages. Option E is correct because the application can proactively dead-letter a message by calling DeadLetterMessageAsync() (or DeadLetterAsync() on the ServiceBusReceiver/MessageReceiver) when it detects a non-retryable or repeatedly failing message, giving explicit control over poison-message handling. Option A is incorrect because Auto-Inflate only scales messaging units/throughput capacity and has nothing to do with message failure handling.

Option B is incorrect because Event Grid advanced filters apply to event subscriptions for Event Grid events, not to Service Bus queue message processing or dead-lettering. Option C is incorrect because setting a null Partition Key only affects session/partition routing behavior and does not address poison messages.

Exam trap

AI-200 often tests the confusion between scaling features (Auto-Inflate) and message failure handling, or between event routing (Event Grid) and dead-lettering, causing candidates to pick irrelevant options.

Practice this question →
43
MCQmedium

You are implementing an asynchronous AI processing pipeline using Azure Event Hubs. Multiple worker instances consume events from the same Event Hub. To prevent duplicate processing and ensure load balancing across workers, how should you manage consumer checkpoints?

A.Configure Azure Service Bus auto-forwarding from Event Hubs to a queue.
B.Use the Azure Event Hubs EventProcessorClient with an Azure Blob Storage checkpoint store.
C.Set the Event Hub partition retention period to zero.
D.Write custom code to maintain consumer offsets in a local memory cache on each worker instance.
AnswerB

EventProcessorClient distributes partition ownership across worker instances, giving load balancing, while the Azure Blob Storage checkpoint store records each partition's offset so processing resumes after failures without duplication. This satisfies the stem's dual requirement: preventing duplicate processing and balancing load across multiple consumers of the same Event Hub.

Why this answer

The EventProcessorClient is the recommended high-level client for consuming events from Event Hubs in .NET and other languages. It uses an Azure Blob Storage checkpoint store to persist checkpoints and partition ownership, enabling load balancing across multiple worker instances and preventing duplicate processing by resuming from the last checkpoint.

Exam trap

AI-200 often tests whether candidates understand that Event Hubs checkpointing requires a durable, shared store like Azure Blob Storage, and that local memory or Service Bus auto-forwarding are not valid solutions for load balancing and duplicate prevention.

How to eliminate wrong answers

Option A is wrong because auto-forwarding from Event Hubs to Service Bus is not a native feature and does not address checkpointing or load balancing for Event Hubs consumers. Option C is wrong because setting retention to zero would delete events immediately, making consumption impossible and not solving duplicate processing. Option D is wrong because storing offsets in local memory on each worker instance is not durable, not shared across instances, and leads to duplicate processing and lost progress on restart.

Practice this question →
44
MCQmedium

You are writing a Python worker application that consumes messages from an Azure Service Bus queue. To prevent message loss during unexpected application crashes, you need to ensure that messages are locked while being processed and only deleted from the queue after successful processing. Which receive mode should you use?

A.Deferred mode
B.SessionLock mode
C.PeekLock mode
D.ReceiveAndDelete mode
AnswerC

PeekLock locks a message for the duration of processing and requires an explicit Complete call to remove it; if the worker crashes, the lock expires and the message becomes available again. ReceiveAndDelete removes the message immediately on receipt, causing loss during crashes.

Why this answer

PeekLock mode is correct because it locks the message for a configurable duration while the consumer processes it, and the message is only deleted after the consumer explicitly completes it. If the application crashes, the lock expires and the message becomes available again, preventing message loss. ReceiveAndDelete would remove the message immediately upon receipt, risking loss on failure.

Exam trap

AI-200 often tests the confusion between PeekLock and ReceiveAndDelete, where candidates incorrectly assume that ReceiveAndDelete is faster and safe enough, ignoring the risk of message loss on crash.

How to eliminate wrong answers

Option A is wrong because Deferred mode is not a receive mode; it is a post-receive operation that defers a message for later retrieval by sequence number, and it still requires an initial receive mode like PeekLock. Option B is wrong because SessionLock mode is used for ordered, session-based processing, not for general crash recovery; it also relies on PeekLock semantics but adds session state. Option D is wrong because ReceiveAndDelete mode removes the message from the queue as soon as it is received, so a crash before processing completes results in permanent message loss.

Practice this question →
45
MCQmedium

You are building an AI document processing pipeline that uses Azure Event Grid to notify downstream services when a new document is uploaded to an Azure Blob Storage container. You need to ensure that the event subscription delivers events to an Azure Function only when the document has a .pdf extension. What should you do?

A.Use event filtering on the event subscription to filter on the subject ending with .pdf.
B.Use a dead-letter destination to store non-.pdf events and process only .pdf events.
C.Create a custom topic and publish events only for .pdf files.
D.Configure the Azure Function to check the file extension and ignore non-.pdf files.
AnswerA

Event Grid supports event filtering based on the event subject, event type, and custom properties. For Blob Storage events, the subject contains the blob path. You can configure a subject suffix filter to only deliver events where the subject ends with .pdf. This is the simplest and most efficient way to achieve the requirement.

Why this answer

Azure Event Grid event subscriptions support filtering based on the event subject. For Blob Storage events, the subject is the full path to the blob. By configuring a subject suffix filter with '.pdf', you ensure that only events for .pdf files are delivered to the Azure Function.

This reduces unnecessary invocations and aligns with the requirement.

Exam trap

The trap here is assuming that filtering must be done in the consumer code, when Event Grid provides built-in filtering capabilities.

Practice this question →
46
MCQeasy

Your application uses Azure Event Grid to deliver events to an Azure Function webhook. Due to a downstream database outage, the Azure Function returns HTTP 500 errors. How does Event Grid handle event delivery when the endpoint fails?

A.Event Grid stops the event subscription until manually restarted by an administrator.
B.Event Grid immediately discards the event upon receiving the first HTTP 500 error.
C.Event Grid automatically migrates the event to an Azure Service Bus queue.
D.Event Grid retries delivery using an exponential backoff retry policy for up to 24 hours.
AnswerD

Event Grid treats non-2xx responses as delivery failures and retries with exponential backoff, extending up to 24 hours before dead-lettering. This satisfies the scenario by absorbing the transient database outage without dropping events or requiring custom retry logic in the function.

Why this answer

Azure Event Grid guarantees at-least-once delivery by retrying failed event deliveries using an exponential backoff policy. When a webhook returns HTTP 500, Event Grid treats it as a retryable failure and continues retrying for up to 24 hours, after which the event is either dropped or sent to a dead-letter destination if configured. This built-in retry mechanism ensures transient downstream failures do not immediately lose events.

Exam trap

AI-200 often tests the misconception that Event Grid drops events on the first failure or that it automatically routes to Service Bus, when the actual behavior is exponential backoff retries for up to 24 hours with optional dead-lettering.

How to eliminate wrong answers

Option A is wrong because Event Grid does not stop the event subscription on endpoint failure; it continues retrying and only disables the subscription after prolonged failure or if the endpoint is deemed invalid (e.g., 404 or 401). Option B is wrong because Event Grid does not discard events on the first 500 error; it retries with backoff, and only drops after the 24-hour retry window expires. Option C is wrong because Event Grid does not automatically migrate events to Service Bus; dead-lettering to a Storage Blob container is the supported mechanism, and it must be explicitly configured.

Practice this question →
47
Multi-Selecthard

Your AI processing pipeline requires high-throughput streaming ingestion and retention of telemetry data. Which THREE features or capabilities are native to Azure Event Hubs? Each correct answer represents a complete capability.

Select 3 answers
A.Event Hubs Capture for automatically batching and saving stream data to Azure Storage
B.Native webhook push delivery for discrete serverless event triggers
C.Consumer Groups enabling multiple independent applications to read the stream
D.Partitioned consumer architecture allowing parallel stream processing
E.Automatic dead-lettering of messages exceeding a MaxDeliveryCount threshold
AnswersA, C, D

Event Hubs Capture automatically batches streaming telemetry and writes it to Azure Blob Storage or Azure Data Lake Storage, satisfying the retention requirement without custom consumer code. It operates on the throughput unit's time and size windows, so high-throughput ingestion persists durably while downstream analytics read the same stream independently.

Why this answer

Option A is correct because Event Hubs Capture is a native feature that automatically batches streaming data and writes it to Azure Blob Storage or Azure Data Lake Storage (in Avro format) based on a time or size window, satisfying the retention requirement without custom code. Option C is correct because Consumer Groups are a native Event Hubs construct that lets multiple independent applications each maintain their own offset and read the same event stream independently, which is essential for multiple downstream consumers. Option D is correct because Event Hubs partitions the stream and allows multiple receivers to process partitions in parallel, which is the foundation of its high-throughput streaming ingestion and parallel processing model.

Option B is not correct because Event Hubs does not natively push events via webhooks for serverless triggers; that pattern belongs to Event Grid, whereas Event Hubs uses AMQP/Kafka pull-based consumption. Option E is not correct because automatic dead-lettering based on a MaxDeliveryCount threshold is a Service Bus queue/subscription feature, not a native Event Hubs capability.

Exam trap

AI-200 often tests the Event Hubs vs Service Bus feature bleed — candidates attribute Service Bus dead-lettering or Event Grid webhook push to Event Hubs, when those are distinct service capabilities.

Practice this question →
48
MCQeasy

Your organization requires that all data transmitted to an Azure Service Bus namespace is encrypted in transit using Transport Layer Security (TLS). What is the minimum required TLS version enforced by modern Azure Service Bus secure baselines?

A.SSL 3.0
B.TLS 1.2
C.Plaintext HTTP with custom Base64 encoding
D.TLS 1.0
AnswerB

Azure Service Bus secure baselines enforce TLS 1.2 as the minimum accepted version, rejecting older TLS 1.0 and 1.1 handshakes. Configuring clients to negotiate TLS 1.2 therefore satisfies the in-transit encryption requirement for the namespace.

Why this answer

Modern Azure Service Bus secure baselines require a minimum of TLS 1.2 for all data in transit. TLS 1.2 is the enforced floor because older protocols (SSL 3.0, TLS 1.0, TLS 1.1) have known cryptographic weaknesses and are deprecated across Azure services.

Exam trap

AI-200 often tests whether candidates know the exact minimum TLS version (1.2) versus deprecated options (SSL 3.0, TLS 1.0) or non-encryption encodings (Base64), tempting them to pick an older protocol they assume is still supported.

How to eliminate wrong answers

Option A is wrong because SSL 3.0 is obsolete and vulnerable to the POODLE attack; Azure Service Bus does not accept it. Option C is wrong because plaintext HTTP with Base64 encoding provides no encryption at all — Base64 is an encoding, not a cipher, and does not satisfy TLS requirements. Option D is wrong because TLS 1.0 is deprecated and does not meet the modern Azure secure baseline, which mandates TLS 1.2 or higher.

Practice this question →
49
MCQeasy

Your organization uses Azure Event Grid to route IoT device lifecycle events. You want to ensure that events published to your custom topic are encrypted at rest using Microsoft-managed keys by default. Which action is required to enable this?

A.You must enable Event Hubs Capture on the topic.
B.You must configure a Storage Account dead-letter container.
C.No action is required; encryption at rest using Microsoft-managed keys is enabled by default.
D.You must link an Azure Key Vault instance during topic creation.
AnswerC

Azure Event Grid encrypts data at rest automatically using Microsoft-managed keys for custom topics and system topics; no configuration or customer key vault is needed. This default behaviour satisfies the requirement without any engineer action.

Why this answer

Azure Event Grid automatically encrypts all events and data at rest using Microsoft-managed keys (MMK) with no configuration required. This encryption applies to custom topics, system topics, and domains by default, ensuring data is protected without any user action. Therefore, the correct answer is that no action is needed to enable encryption at rest with Microsoft-managed keys.

Exam trap

AI-200 often tests the misconception that encryption at rest requires explicit configuration, confusing it with customer-managed key scenarios or other services like Event Hubs.

How to eliminate wrong answers

Option A is wrong because Event Hubs Capture is a feature of Azure Event Hubs, not Event Grid, and it is used for capturing streaming data to storage, not for enabling encryption. Option B is wrong because a dead-letter container is used to store undelivered events, not to provide encryption; it is a separate configuration for handling delivery failures. Option D is wrong because linking an Azure Key Vault instance is required only when you want to use customer-managed keys (CMK) for encryption, not for Microsoft-managed keys, which are enabled by default.

Practice this question →
50
MCQhard

You are architecting an AI-driven video analytics pipeline using Azure Event Hubs. You need to ensure that frames belonging to the exact same video session are processed in strict chronological order by the same backend stream analytics worker. How should you partition your Event Hub?

A.Increase the consumer group count to match the number of active video sessions.
B.Set the message TTL to zero and enable capture mode on the Event Hub namespace.
C.Include the video session ID as the Partition Key when publishing events to the Event Hub.
D.Deploy an Azure Service Bus Session-enabled queue in front of the Event Hubs ingestion layer.
AnswerC

Partition keys determine which partition receives an event, and Event Hubs preserves order only within a single partition. Using the video session ID as the partition key routes every frame of one session to the same partition, so one stream analytics worker processes them chronologically.

Why this answer

Event Hubs guarantees ordering only within a partition, so all events sharing the same partition key are routed to the same partition and delivered in order to a single consumer. Using the video session ID as the partition key ensures every frame from a session lands on one partition, where one stream analytics worker processes them chronologically. This is the standard pattern for session affinity and ordered processing in Event Hubs.

Exam trap

AI-200 often tests the misconception that consumer groups or TTL settings control ordering, when the only way to guarantee per-session order in Event Hubs is to use the session ID as the partition key.

How to eliminate wrong answers

Option A is wrong because consumer groups are independent views of the same stream for different readers; increasing their count does not control partitioning or guarantee that a session's frames go to one worker. Option B is wrong because TTL controls message expiration and Capture writes data to Blob Storage; neither affects ordering or partition assignment. Option D is wrong because Service Bus sessions provide ordered delivery but inserting it in front of Event Hubs adds a redundant layer and does not address Event Hubs partitioning — the question asks how to partition the Event Hub itself.

Practice this question →
51
MCQeasy

Your team is building an AI document parser. When a user uploads a PDF to Azure Blob Storage, an event triggers an Azure Function. You want to view the delivery success rate and latency metrics of these events in the Azure Portal. Which Azure service dashboard provides these metrics out-of-the-box?

A.Azure Container Apps Health Probes
B.Azure Cosmos DB Insights
C.Azure AI Services Dashboard
D.Azure Event Grid Metrics
AnswerD

Azure Event Grid Metrics, viewed through the Azure Portal, exposes delivery success rate and latency for event subscriptions out-of-the-box. Blob Storage and Function metrics do not surface event delivery telemetry, so Event Grid Metrics directly satisfies the monitoring requirement.

Why this answer

Azure Event Grid emits built-in platform metrics — including Publish Success Rate, Delivery Success Rate, Dropped Events, Matched Events, and delivery latency — that are surfaced automatically in the Azure Portal under the Event Grid topic or system topic's Metrics blade. No additional instrumentation is required to view these out-of-the-box.

Exam trap

AI-200 often tests whether candidates know that Event Grid exposes delivery metrics natively in Azure Monitor, rather than assuming they must build custom telemetry or use another service's dashboard.

How to eliminate wrong answers

Option A is wrong because Azure Container Apps Health Probes report on container liveness/readiness, not on Event Grid event delivery. Option B is wrong because Cosmos DB Insights is a monitoring workbook for Cosmos DB request units, latency, and throttling — unrelated to Event Grid delivery telemetry. Option C is wrong because the Azure AI Services Dashboard surfaces cognitive-service usage and quota metrics, not Event Grid delivery success or latency.

Practice this question →
52
MCQeasy

Your organization uses Azure Event Hubs to ingest telemetry from smart meters. You want to grant an external analytics vendor read-only access to the Event Hub data without sharing your master connection string or account keys. What should you create?

A.An Event Grid subscription key with administrator rights.
B.A SAS rule with 'Manage' permissions.
C.A Storage Account connection string with Contributor access.
D.A SAS authorization rule with 'Listen' permissions only, or assign the Azure Event Hubs Data Receiver RBAC role.
AnswerD

A SAS authorization rule scoped to 'Listen' grants send-free, read-only access, while the Azure Event Hubs Data Receiver RBAC role achieves the same via Microsoft Entra ID. Both avoid sharing the master connection string or account keys, satisfying the vendor's read-only requirement.

Why this answer

To grant read-only access to Event Hubs without sharing master keys, you can create a SAS authorization rule with only 'Listen' permissions or assign the Azure Event Hubs Data Receiver RBAC role to the vendor's identity. Both methods follow the principle of least privilege and allow the vendor to receive events without management or send rights.

Exam trap

AI-200 often tests whether candidates confuse Event Grid and Event Hubs permissions, or mistakenly choose 'Manage' permissions when read-only is required.

How to eliminate wrong answers

Option A is wrong because Event Grid subscription keys are for Event Grid, not Event Hubs, and administrator rights violate least privilege. Option B is wrong because a SAS rule with 'Manage' permissions grants full control, including send and manage, which is excessive for read-only access. Option C is wrong because a Storage Account connection string with Contributor access is unrelated to Event Hubs and grants broad permissions to storage, not Event Hubs data.

Practice this question →
53
MCQmedium

Your enterprise application uses Azure Service Bus Topics. A specific downstream billing system needs to receive only messages where the 'Region' property in the message application properties equals 'NorthAmerica'. What should you create on the Service Bus subscription?

A.An Event Grid Advanced Filter on the namespace topic
B.A Storage Queue access policy
C.An Event Hubs Partition Key routing rule
D.A SQL Filter or Correlation Filter on the subscription
AnswerD

A SQL Filter or Correlation Filter on the subscription evaluates message application properties, so it routes only messages whose Region property equals NorthAmerica to the billing system. This satisfies the constraint of filtering on a custom property, which the topic's subscriptions apply before delivering messages to that downstream receiver.

Why this answer

Azure Service Bus subscriptions support SQL Filters and Correlation Filters that evaluate message application properties (e.g., Region = 'NorthAmerica') and route only matching messages to the subscription. A Correlation Filter is especially efficient for equality checks on properties like Region, while SQL Filters allow more complex expressions. This is the native filtering mechanism for Service Bus Topics.

Exam trap

AI-200 often tests whether candidates confuse Service Bus subscription filters with Event Grid filters or Event Hubs partitioning — remember filtering on Service Bus Topics is done via SQL/Correlation Filters on subscriptions.

How to eliminate wrong answers

Option A is wrong because Event Grid Advanced Filters apply to Event Grid subscriptions, not Service Bus topic subscriptions, and Event Grid is a different eventing service. Option B is wrong because Storage Queue access policies control authorization to a Storage Queue, not message routing/filtering in Service Bus. Option C is wrong because Event Hubs Partition Key routing is a partitioning concept for Event Hubs, not a filtering mechanism for Service Bus subscriptions.

Practice this question →
54
MCQmedium

Your Azure Event Hubs namespace is experiencing high throughput spikes from AI inference nodes. You notice that some client producers are receiving 'QuotaExceededException' errors. What is the root cause and how should you remediate it?

A.Ingress or egress limits have been exceeded; enable Auto-Inflate on the Event Hubs namespace.
B.The partition count has been exceeded; decrease the number of consumer groups.
C.The SAS token has expired; regenerate the connection string.
D.The message retention period has expired; increase retention days.
AnswerA

QuotaExceededException indicates the namespace's ingress or egress throughput units were exceeded by the inference producers. Auto-Inflate raises the throughput unit count automatically when limits are breached, restoring capacity without manual intervention, which directly addresses the spike-driven quota failures.

Why this answer

QuotaExceededException in Azure Event Hubs is thrown when the namespace's throughput unit (TU) or processing unit (PU) capacity is saturated — specifically when ingress or egress rates exceed the provisioned limits. Enabling Auto-Inflate automatically scales the TU count (up to a configured maximum) to absorb the spike, which is the correct remediation for bursty AI inference workloads. Auto-Inflate is the native elasticity mechanism for Event Hubs and directly addresses the quota breach.

Exam trap

AI-200 often tests the distinction between authentication errors (SAS expiry), configuration limits (partition count), and runtime throughput quotas — candidates frequently confuse QuotaExceededException with partition or retention issues instead of recognizing it as a TU/PU capacity breach.

How to eliminate wrong answers

Option B is wrong because partition count is a fixed property set at creation (or via a support ticket for existing namespaces) and is not a runtime quota that throws QuotaExceededException; consumer groups do not consume partitions in a way that would trigger this error. Option C is wrong because an expired SAS token produces an AuthenticationException or 401 Unauthorized, not a QuotaExceededException — the error class is fundamentally different. Option D is wrong because retention expiry affects message availability for consumers (older events are dropped), not producer ingress; it never manifests as a quota exception on the send path.

Practice this question →
55
MCQeasy

An AI inference pipeline uses Azure Event Hubs to ingest telemetry. Your consumer application needs to read events starting from a specific timestamp to replay historical data for model retraining. Which feature of Event Hubs enables this capability?

A.Starting position based on Enqueued Time
B.Event Hubs Capture window
C.Event Grid event retention policy
D.Service Bus message lock duration
AnswerA

Event Hubs consumers can specify a starting position using the enqueued time of events, allowing the consumer to begin reading from a chosen timestamp. This replays historical telemetry for model retraining without processing the entire stream.

Why this answer

Event Hubs consumers can specify a starting position using the Enqueued Time of events, allowing them to begin reading from a specific timestamp. This is implemented via the EventPosition.fromEnqueuedTime() method in the SDKs, which seeks to the first event with an enqueued time greater than or equal to the given timestamp. This feature is essential for replaying historical data for model retraining, as it lets the consumer skip older events and start at the desired point in time.

Exam trap

AI-200 often tests the confusion between Event Hubs and Service Bus features, or between ingestion and archival mechanisms, so candidates may mistakenly select Capture or Service Bus lock duration when asked about consumer starting positions.

How to eliminate wrong answers

Option B is wrong because Event Hubs Capture is a feature that automatically saves streaming data to Azure Blob Storage or Data Lake, but it does not provide a mechanism for consumers to start reading from a specific timestamp; it's for archival, not for consumer positioning. Option C is wrong because Event Grid is a separate event routing service and does not have a retention policy for Event Hubs events; Event Hubs has its own retention settings (1-90 days) that control how long events are available, but this is not a feature that enables starting from a timestamp. Option D is wrong because Service Bus message lock duration is a concept from Azure Service Bus (a different messaging service) and is unrelated to Event Hubs; it controls how long a message is locked for processing in Service Bus queues/subscriptions, not the starting position in Event Hubs.

Practice this question →
56
MCQhard

Your enterprise AI system uses Azure Service Bus. A background job processes messages from a subscription. If an exception occurs, the message must be abandoned, but you want to ensure that after 5 failed delivery attempts, the message is automatically moved to a dead-letter queue without custom retry logic in code. How should you configure this?

A.Implement a Session-based retry policy with an exponential backoff timer.
B.Set the MaxDeliveryCount property on the Service Bus subscription to 5.
C.Enable DeadLetteringOnMessageExpiration on the subscription settings.
D.Configure the LockDuration property to 5 seconds.
AnswerB

MaxDeliveryCount governs how many times Service Bus delivers a message before automatically dead-lettering it. Setting it to 5 on the subscription means the fifth failed delivery triggers the built-in dead-letter mechanism, removing the need for custom retry logic in the background job.

Why this answer

The MaxDeliveryCount property on a Service Bus subscription (or queue) specifies how many times a message can be delivered before it is automatically dead-lettered. Setting it to 5 ensures that after 5 failed delivery attempts (where the message is abandoned or the lock expires), Service Bus moves it to the dead-letter queue without any custom retry logic.

Exam trap

AI-200 often tests whether candidates confuse MaxDeliveryCount (automatic dead-lettering after N failures) with DeadLetteringOnMessageExpiration (TTL-based) or LockDuration (lock timeout), and whether they know that dead-lettering can be broker-managed without custom code.

How to eliminate wrong answers

Option A is wrong because session-based retry with exponential backoff is a custom pattern that requires code-level implementation and is used for ordered processing, not automatic dead-lettering after a fixed attempt count. Option C is wrong because DeadLetteringOnMessageExpiration moves messages to the DLQ when their TTL expires, not after a specific number of delivery failures. Option D is wrong because LockDuration controls how long a receiver holds an exclusive lock on a message before it becomes available again — setting it to 5 seconds would cause frequent lock expirations and premature redelivery, not controlled dead-lettering after 5 attempts.

Practice this question →
57
Multi-Selecthard

When designing an Azure Event Hubs streaming pipeline for AI telemetry, which THREE components or configurations are required to consume events reliably using the EventProcessorClient? Each correct answer represents a necessary element.

Select 3 answers
A.A Checkpoint Store (such as an Azure Blob Storage container client)
B.An active Azure Service Bus subscription connection
C.An Event Hubs Consumer Group name
D.An Event Grid custom topic endpoint URL
E.Event Hubs connection string and Event Hub name
AnswersA, C, E

The Checkpoint Store, typically an Azure Blob Storage container client, persists partition offsets and ownership leases so the EventProcessorClient resumes after restarts or rebalances. Without it, progress is lost and events are reprocessed or skipped, defeating reliable at-least-once consumption.

Why this answer

Option A is correct because EventProcessorClient requires a CheckpointStore (typically backed by an Azure Blob Storage container client) to persist checkpoints and ownership information so partitions can be processed reliably and resumed after failures. Option C is correct because a Consumer Group name is mandatory when constructing the EventProcessorClient, as it defines the logical view of the event stream that the processor reads from and isolates offsets/checkpoints per group. Option E is correct because the client must be given the Event Hubs namespace connection string and the specific Event Hub name to connect and receive events.

Option B is incorrect because Event Hubs is not Service Bus, so no Service Bus subscription connection is involved. Option D is incorrect because Event Grid custom topics are for event routing/notification, not for consuming Event Hubs streams with EventProcessorClient.

Exam trap

AI-200 often tests the confusion between Event Hubs and Service Bus consumption models, tricking candidates into selecting Service Bus subscriptions or Event Grid endpoints as required components for EventProcessorClient.

Practice this question →
58
MCQmedium

Your application sends messages to an Azure Service Bus queue. A downstream worker needs to postpone processing of a specific message until a later time without losing its place in the queue or dead-lettering it. What method should the worker invoke?

A.CompleteMessageAsync()
B.DeferMessageAsync()
C.AbandonMessageAsync()
D.DeadLetterMessageAsync()
AnswerB

DeferMessageAsync() assigns a sequence number and moves the message aside, so it stays in the queue without blocking others or dead-lettering. The worker later retrieves it by that sequence number. This satisfies the requirement to postpone processing while preserving the message's place and avoiding loss.

Why this answer

DeferMessageAsync() postpones processing of a message by setting it aside while preserving its sequence number, allowing the worker to retrieve it later by sequence number without losing its place or dead-lettering it. This is the correct method for temporarily postponing a specific message in Azure Service Bus.

Exam trap

AI-200 often tests the confusion between deferral and abandonment — candidates pick AbandonMessageAsync() thinking it postpones the message, but abandonment immediately releases the lock for redelivery, while deferral preserves the message for later retrieval by sequence number.

How to eliminate wrong answers

Option A is wrong because CompleteMessageAsync() marks the message as successfully processed and removes it from the queue — it does not postpone processing. Option C is wrong because AbandonMessageAsync() releases the message lock and makes it immediately available for redelivery, which does not postpone it to a later time and may cause it to be reprocessed immediately. Option D is wrong because DeadLetterMessageAsync() moves the message to the dead-letter queue, which is a terminal state for messages that cannot be processed — it does not preserve the message for later normal processing.

Practice this question →
59
MCQhard

You are troubleshooting a connection issue where an on-premises worker application cannot connect to an Azure Event Hubs namespace over AMQP port 5671 due to strict corporate firewall rules. Only port 443 outbound traffic is allowed. How can you configure the client connection to bypass this restriction?

A.Deploy an Azure VPN Gateway on the local workstation.
B.Configure the Event Hub client connection to use AMQP over WebSockets (port 443).
C.Switch the connection string to use an Event Grid webhook protocol.
D.Open an Azure Support ticket to whitelist port 5671 on the Azure backbone router.
AnswerB

AMQP over WebSockets tunnels the AMQP protocol inside an HTTPS session on port 443, which the firewall already permits. This preserves the Event Hubs client's AMQP semantics while satisfying the stem's constraint that only outbound 443 traffic is allowed.

Why this answer

Azure Event Hubs supports AMQP over WebSockets, which tunnels AMQP traffic over port 443 (HTTPS). By configuring the Event Hubs client to use WebSockets (e.g., setting the transport type to AmqpWebSockets), the connection uses port 443, which is allowed by the corporate firewall. This is the standard workaround for restrictive firewall environments.

Exam trap

AI-200 often tests the misconception that you can simply open a support ticket to unblock a port on Azure's side, when the firewall restriction is on the customer's network and the correct solution is to use AMQP over WebSockets on port 443.

How to eliminate wrong answers

Option A is wrong because deploying an Azure VPN Gateway on a local workstation is not a valid or practical solution for bypassing port restrictions and does not directly address the client connection configuration. Option C is wrong because Event Grid webhook protocol is a different service and cannot be used to connect to Event Hubs. Option D is wrong because Azure cannot whitelist port 5671 on the customer's corporate firewall; the restriction is on the customer side, and Azure support cannot change that.

Practice this question →
60
MCQmedium

You are designing an enterprise messaging solution using Azure Service Bus. You need to ensure that messages published within a transaction (involving multiple messages sent to different queues) either all succeed or all fail together. What feature should you use?

A.Storage Account atomic blob leases
B.Event Grid atomic batch publishing mode
C.Event Hubs transaction coordinator checkpointing
D.Service Bus client transaction scope (TransactionScope in .NET)
AnswerD

Service Bus client transaction scope groups multiple sends across different queues into one atomic operation, so all messages commit or roll back together. This directly satisfies the stem's all-or-nothing constraint for a transaction spanning several queues, unlike broker-side features that operate per-entity.

Why this answer

The correct feature is the Service Bus client transaction scope (TransactionScope in .NET). Azure Service Bus supports transactions that allow multiple messages sent to different queues or topics to be committed atomically. Using TransactionScope in .NET, developers can group send operations so that either all messages are committed or none are.

This ensures consistency across multiple entities within a single transaction.

Exam trap

AI-200 often tests the confusion between Service Bus transactions and other Azure messaging services' batch or atomic features, leading candidates to choose Event Grid or Event Hubs incorrectly.

How to eliminate wrong answers

Option A is wrong because Storage Account atomic blob leases are used for blob storage concurrency control, not for messaging transactions across Service Bus queues. Option B is wrong because Event Grid does not provide atomic batch publishing mode; it is a pub/sub event routing service with at-least-once delivery, not transactional messaging. Option C is wrong because Event Hubs transaction coordinator checkpointing is related to consumer offset management, not atomic multi-queue message sending; Event Hubs does not support cross-entity transactions like Service Bus.

Practice this question →
61
Multi-Selecthard

You are configuring network security for an enterprise Azure Service Bus Premium namespace. Which THREE networking features can you configure to secure the namespace? (Choose three)

Select 3 answers
A.Private endpoints using Azure Private Link
B.Event Grid MQTT broker certificate authentication
C.IP firewall rules
D.Virtual Network (VNet) service endpoints
E.Blob storage container access policies
AnswersA, C, D

Azure Private Link maps a private endpoint into your virtual network, giving the Service Bus Premium namespace a private IP and removing public internet exposure. This satisfies the stem's requirement for a configurable namespace-level networking feature.

Why this answer

Option A (Private endpoints using Azure Private Link) is correct because Service Bus Premium supports Private Link, which assigns a private IP from your VNet to the namespace and removes exposure to the public internet, allowing secure access over the Microsoft backbone network. Option C (IP firewall rules) is correct because Service Bus Premium lets you restrict access to specific public IP addresses or CIDR ranges via the namespace's networking firewall, blocking all other public traffic by default. Option D (Virtual Network (VNet) service endpoints) is correct because Service Bus Premium supports VNet service endpoints, which extend your VNet identity to the service over the Azure backbone and let you restrict access to specific subnets.

Option B is incorrect because Event Grid MQTT broker certificate authentication applies to Event Grid's MQTT support, not to Azure Service Bus. Option E is incorrect because Blob storage container access policies are a storage feature unrelated to securing a Service Bus namespace.

Exam trap

AI-200 often tests whether candidates can separate Service Bus networking controls (Private Endpoint, IP firewall, VNet service endpoints) from unrelated features like Event Grid MQTT authentication or Blob storage policies that sound security-related but do not secure the namespace.

Practice this question →
62
MCQeasy

Your team is building an AI solution that processes thousands of images uploaded to Azure Blob Storage daily. Each image upload must trigger an immediate Azure Function to invoke Azure Cognitive Services for metadata extraction. Which event-driven messaging service should you choose for this near real-time pub/sub architecture?

A.Azure Service Bus Topics
B.Azure Storage Queues
C.Azure Event Hubs
D.Azure Event Grid
AnswerD

Event Grid delivers Blob Storage events with near real-time push semantics, triggering the Azure Function immediately on each upload. Its native blob event source and low-latency pub/sub routing satisfy the immediate invocation constraint better than polling-based alternatives.

Why this answer

Azure Event Grid is purpose-built for near real-time, event-driven pub/sub with native first-class integration to Blob Storage events (BlobCreated) and Azure Functions. It pushes events within milliseconds of the blob upload, making it the correct choice for triggering a Function that calls Cognitive Services for metadata extraction.

Exam trap

AI-200 often tests the distinction between push-based event routing (Event Grid) and pull-based or streaming services (Storage Queues, Event Hubs), causing candidates to pick Event Hubs for blob-trigger scenarios.

How to eliminate wrong answers

Option A is wrong because Service Bus Topics are a brokered messaging service optimized for enterprise messaging patterns (ordering, sessions, transactions), not for native Blob Storage event integration — you would need to build a bridge to get blob events into Service Bus. Option B is wrong because Storage Queues are polling-based, not push-based, so they cannot deliver near real-time triggers and lack native Blob event integration. Option C is wrong because Event Hubs is a high-throughput streaming ingestion service designed for telemetry and big-data pipelines, not for discrete blob-upload event routing to Functions.

Practice this question →
63
MCQeasy

Your application publishes events to an Azure Event Grid custom topic. You need to restrict publishing access so that only clients with a specific User-Assigned Managed Identity can send events. How should you secure the topic?

A.Embed the primary SAS access key into the client's application environment variables.
B.Assign the 'Event Grid Data Sender' role to the Managed Identity on the Event Grid topic resource scope.
C.Enable AMQP 1.0 token authentication on the event subscription.
D.Configure an Azure Storage firewall rule on the topic endpoint.
AnswerB

Role-Based Access Control on the topic resource scope grants the managed identity publish permissions via the Event Grid Data Sender role, which authorises sending events to that specific topic. This satisfies the requirement that only clients holding that identity can publish.

Why this answer

Azure Event Grid integrates with Azure RBAC, and the built-in role 'Event Grid Data Sender' grants permission to publish events to a topic or namespace. Assigning this role to the user-assigned managed identity at the Event Grid topic resource scope allows only that identity to publish, satisfying the least-privilege requirement. This is the standard Entra ID-based authorization model for Event Grid publishing.

Exam trap

AI-200 often tests whether candidates confuse Event Grid's RBAC roles with Event Hubs/Service Bus roles, so picking a role like 'Azure Event Hubs Data Sender' or using SAS keys instead of 'Event Grid Data Sender' is the common mistake.

How to eliminate wrong answers

Option A is wrong because embedding the primary SAS key in environment variables uses shared-key authentication, not identity-based authorization, and any client with the key could publish. Option C is wrong because AMQP 1.0 is the protocol used by Event Hubs and Service Bus, not Event Grid, and Event Grid does not use AMQP token authentication for publishing. Option D is wrong because Azure Storage firewall rules apply to Storage accounts, not Event Grid topics, and they are network controls rather than identity-based authorization.

Practice this question →
64
MCQmedium

Your organization is implementing strict compliance standards. All event payloads transmitted through Azure Event Grid must be encrypted in transit using TLS 1.3 and encrypted at rest using a customer-managed key (CMK). Which Azure Event Grid tier supports configuring customer-managed keys?

A.Event Grid Standard tier
B.Event Grid Basic tier
C.Event Grid Basic tier with custom schema extensions
D.Event Grid Premium tier
AnswerD

Event Grid Premium tier supports customer-managed keys for encryption at rest, satisfying the CMK constraint. Basic and Standard tiers encrypt at rest only with Microsoft-managed keys, so they cannot meet the compliance requirement. Premium also enforces TLS 1.3 for in-transit encryption of event payloads.

Why this answer

Customer-managed keys (CMK) for encryption at rest are supported only on the Event Grid Premium tier. Premium also supports Private Link, managed identity delivery, and higher throughput. Standard and Basic tiers do not support CMK configuration.

Exam trap

AI-200 often tests the assumption that CMK is available on all Event Grid tiers; in reality only Premium supports CMK, Private Link, and managed identity delivery.

How to eliminate wrong answers

Option A is wrong because Event Grid Standard tier does not support customer-managed keys for encryption at rest. Option B is wrong because Basic tier lacks CMK support and many enterprise features. Option C is wrong because custom schema extensions do not add CMK capability; the tier itself must be Premium.

Practice this question →
65
MCQhard

You are troubleshooting a high-throughput stream processing pipeline using Azure Event Hubs. Consumers are experiencing lag because messages are accumulating faster than they can be processed. You want to temporarily replay historical events from 2 hours ago without altering the current consumer group offsets permanently. What should you do?

A.Enable Geo-Disaster Recovery to force the secondary region to sync historical logs.
B.Delete the existing consumer group and recreate it with a 2-hour retention limit.
C.Purge all messages from the Event Hub using the Azure CLI az eventhubs purge command.
D.Create a new temporary consumer group and initialize the event receiver with a custom starting offset based on enqueued timestamp.
AnswerD

A separate consumer group maintains its own offsets, so initialising its receiver with an enqueued-time starting position replays the last two hours while leaving the production consumer group's checkpoints untouched, satisfying the stem's non-permanent, historical replay constraint.

Why this answer

Creating a new temporary consumer group and initializing the event receiver with a custom starting offset based on enqueued timestamp is correct because it allows replaying historical events without affecting the existing consumer group's offsets. The new consumer group starts from a specified time, and the original group continues from its current position. Other options do not achieve this.

Exam trap

AI-200 often tests the confusion between consumer group offsets and retention, where candidates might think deleting a consumer group or purging messages is needed, but the correct approach is a new consumer group with a custom starting offset.

How to eliminate wrong answers

Option A is wrong because Geo-Disaster Recovery is for failover to a secondary region, not for replaying historical events; it also does not sync historical logs. Option B is wrong because deleting and recreating a consumer group with a retention limit does not allow replaying from a specific time; it would start from the latest or earliest depending on configuration, and it would disrupt the existing group. Option C is wrong because purging messages deletes them permanently, which is the opposite of replaying historical events.

Practice this question →
66
MCQmedium

Your team needs to process high-volume clickstream data from a web application using Apache Kafka protocols while leveraging Azure-managed infrastructure. Which Azure service should you deploy?

A.Azure Event Grid
B.Azure Notification Hubs
C.Azure Service Bus
D.Azure Event Hubs
AnswerD

Event Hubs exposes a Kafka-compatible endpoint, so existing Kafka producers and consumers connect without code changes, while Azure handles partitioning, throughput units and retention. This satisfies the stem's dual constraint: Kafka protocol compatibility plus fully managed PaaS infrastructure rather than self-managed broker VMs.

Why this answer

Azure Event Hubs is a fully managed, real-time data ingestion service that supports the Apache Kafka protocol via its Kafka endpoint. It is designed for high-throughput event streaming and can handle clickstream data at scale. By deploying Event Hubs, you can use Kafka producers and consumers without managing Kafka clusters.

Exam trap

AI-200 often tests the confusion between Event Hubs and Service Bus, where candidates may choose Service Bus for high-volume streaming, but Event Hubs is the Kafka-compatible choice.

How to eliminate wrong answers

Option A is wrong because Azure Event Grid is a publish-subscribe service for discrete events, not a high-volume streaming platform, and it does not support Kafka protocols. Option B is wrong because Azure Notification Hubs is for sending push notifications to mobile devices, not for processing clickstream data. Option C is wrong because Azure Service Bus is an enterprise message broker for reliable messaging, not optimized for high-volume streaming and does not natively support Kafka.

Practice this question →
67
MCQeasy

An AI application uses Azure Service Bus queues for task distribution. A background worker receives a message, but needs more time to complete the lengthy AI inference task before the message lock expires. Which method should the worker invoke?

A.AbandonAsync
B.DeadLetterAsync
C.RenewLockAsync
D.CompleteAsync
AnswerC

RenewLockAsync extends the message lock duration before it expires, preventing the Service Bus queue from redelivering the message while the lengthy AI inference task is still running. This directly satisfies the stem's need for more processing time without losing the lock.

Why this answer

RenewLockAsync extends the lock on a message, giving the worker more time to process it before the lock expires. This prevents the message from being delivered to another worker while the current one is still processing.

Exam trap

AI-200 often tests the difference between Complete, Abandon, DeadLetter, and RenewLock. Candidates may confuse Abandon (release lock) with RenewLock (extend lock), especially when the task needs more time.

How to eliminate wrong answers

Option A is wrong because AbandonAsync releases the lock and makes the message available again, which would cause it to be reprocessed. Option B is wrong because DeadLetterAsync moves the message to the dead-letter queue, which is for messages that cannot be processed. Option D is wrong because CompleteAsync marks the message as processed and removes it from the queue, which should only be done after successful processing.

Practice this question →
68
MCQmedium

You are designing an asynchronous AI image classification workflow. Client applications upload images to Azure Blob Storage and need to be notified immediately when processing completes. The notification must include custom metadata generated by the AI worker. Which architecture should you implement?

A.Use Azure Service Bus topics with session IDs set to the image hash.
B.Configure an Azure Storage queue that triggers whenever a blob is modified.
C.Poll the Azure Blob Storage container metadata every 5 seconds from the client app.
D.The AI worker publishes a custom event to an Azure Event Grid Topic upon completion.
AnswerD

Event Grid delivers the worker's custom event payload, including your metadata properties, to subscribers within seconds via push delivery. This satisfies the immediate notification requirement with custom metadata, which Blob Storage change events alone cannot carry.

Why this answer

The AI worker publishing a custom event to an Azure Event Grid Topic upon completion is correct because Event Grid supports custom events with metadata and can push notifications to subscribers immediately. This allows clients to receive the custom metadata generated by the worker. Other options do not provide immediate notification with custom metadata.

Exam trap

AI-200 often tests the confusion between Event Grid and Service Bus, where candidates might choose Service Bus for notifications, but Event Grid is designed for reactive, event-driven scenarios with custom metadata.

How to eliminate wrong answers

Option A is wrong because Service Bus topics with session IDs are for ordered message processing, not for immediate notification with custom metadata; they require polling or a receiver. Option B is wrong because an Azure Storage queue triggered by blob modification does not include custom metadata from the AI worker and may not be immediate. Option C is wrong because polling every 5 seconds is inefficient, not immediate, and does not push notifications.

Practice this question →
69
MCQmedium

Your team is building an asynchronous order processing pipeline. If a downstream AI service fails to process a message from a Service Bus queue after 5 delivery attempts, the message must be automatically removed from active processing and preserved for manual inspection. What should you configure?

A.Enable Duplicate Detection with a history window of 5 attempts.
B.Configure the Max Delivery Count property on the queue and enable dead-lettering on message expiration or failure.
C.Set the AutoDeleteOnIdle property on the queue to 5 minutes.
D.Implement Event Grid dead-lettering pointing to an Azure Blob Storage container.
AnswerB

Setting Max Delivery Count to five moves the message to the dead-letter queue once the sixth delivery attempt would occur, satisfying the automatic removal requirement. Dead-lettering on failure preserves the message for manual inspection rather than discarding it, which matches the stem's constraint exactly.

Why this answer

Configuring Max Delivery Count on the queue (for example, 5) combined with dead-lettering on message expiration or delivery failure ensures that after five unsuccessful delivery attempts the message is moved to the dead-letter queue (DLQ) rather than being retried indefinitely or discarded. The DLQ preserves the message payload and failure metadata for manual inspection and reprocessing. This is the native Service Bus mechanism for poison-message handling.

Exam trap

AI-200 often tests whether candidates confuse message expiration/TimeToLive with delivery-count-based dead-lettering, or mistakenly believe AutoDeleteOnIdle or Duplicate Detection handles poison messages.

How to eliminate wrong answers

Option A is wrong because Duplicate Detection suppresses duplicate message IDs within a time window; it has nothing to do with delivery attempt counting or dead-lettering, and a 'history window of 5 attempts' is not a valid configuration concept. Option C is wrong because AutoDeleteOnIdle deletes an idle queue (or topic/subscription) after a period of inactivity, which would destroy the queue itself, not move failed messages aside. Option D is wrong because Event Grid dead-lettering applies to Event Grid event subscriptions and delivers undeliverable events to a storage container; it does not govern Service Bus queue delivery attempts or the Service Bus DLQ.

Practice this question →
70
MCQeasy

Your team runs an AI content-moderation service. When a user submits content, an Azure Function publishes an event to an Azure Event Grid custom topic. A webhook subscription delivers the event to a partner's HTTPS endpoint. The partner reports that they sometimes receive the same event multiple times and asks how to handle this. You need to advise the partner on the correct expectation for Event Grid delivery. What should you tell them?

A.Event Grid provides at-least-once delivery, so the partner should make their endpoint idempotent using the event ID.
B.Event Grid provides exactly-once delivery only when the subscriber returns HTTP 200, so duplicates mean the endpoint is returning errors.
C.Event Grid provides at-most-once delivery, so missing events are expected and duplicates are impossible.
D.Event Grid guarantees exactly-once delivery, so any duplicates indicate a misconfigured subscription filter.
AnswerA

Event Grid delivers events with an at-least-once guarantee, so duplicate deliveries are expected. Each event carries a unique id property, and the partner can use it to detect and discard duplicates. Making the endpoint idempotent is the recommended practice. This accurately describes Event Grid's delivery semantics and gives the partner an actionable solution.

Why this answer

Event Grid uses at-least-once delivery, so subscribers may receive the same event more than once, particularly during retries. The event's id property uniquely identifies each event, and subscribers should use it to implement idempotent processing. Claiming exactly-once or at-most-once semantics misrepresents the service and would lead the partner to mishandle duplicates or ignore potential event loss.

Exam trap

The trap here is assuming that a successful HTTP 200 response guarantees exactly-once delivery, when Event Grid still provides at-least-once semantics across retries.

Practice this question →
71
Multi-Selecthard

You are designing an enterprise cloud solution that integrates Azure Event Grid, Azure Service Bus, and Azure Event Hubs. You need to select the appropriate service for three specific event-driven scenarios. Which THREE pairings of Azure messaging service to scenario are correct? (Choose three)

Select 3 answers
A.Azure Service Bus for managing financial transactions requiring strict ordering, sessions, and dead-lettering.
B.Azure Event Hubs for ingesting 500,000 telemetry events per second from smart grid sensors.
C.Azure Event Grid for routing blob-created notifications to serverless AI functions.
D.Azure Event Hubs for triggering real-time serverless webhooks upon user profile updates.
E.Azure Event Grid for streaming continuous IoT sensor telemetry into Azure Databricks.
AnswersA, B, C

Service Bus provides FIFO delivery through sessions, guaranteeing strict ordering, plus native dead-lettering for unprocessable messages — exactly the transactional messaging semantics the financial scenario demands, unlike Event Grid's at-least-once push or Event Hubs' partition-ordered streaming.

Why this answer

Option A is correct because Azure Service Bus is the enterprise brokered-messaging service that natively supports FIFO ordering via sessions, message sessions for correlated/ordered processing, and built-in dead-letter queues for poison messages, which are exactly the requirements for financial transactions. Option B is correct because Azure Event Hubs is designed for massive-scale event ingestion (millions of events per second, with throughput units or processing units) and is the right fit for 500,000 telemetry events per second from smart grid sensors. Option C is correct because Azure Event Grid is a reactive, push-based event routing service that natively emits blob-created events from Azure Storage and can deliver them to serverless endpoints such as Azure Functions for AI processing.

Option D is not correct because Event Hubs is a high-throughput streaming ingestion service, not a low-latency pub/sub webhook trigger for discrete user profile updates; Event Grid is the appropriate service for that scenario. Option E is not correct because Event Grid is not built for continuous high-volume telemetry streaming into analytics engines like Databricks; Event Hubs (often with Capture or Stream Analytics) is the correct ingestion path for that workload.

Exam trap

AI-200 often tests confusion between Event Grid (reactive discrete events) and Event Hubs (high-throughput streaming), or between Service Bus (brokered messaging with ordering) and Event Grid (simple event routing).

Practice this question →
72
MCQhard

Your enterprise architecture uses Azure Service Bus Topics and Subscriptions with geo-disaster recovery paired namespaces. A disaster occurs, and you trigger a failover to the secondary region. What happens to the messages currently in the subscriptions of the primary namespace?

A.All queued messages are automatically migrated to the secondary region within 5 seconds.
B.Azure Event Grid automatically replays all lost messages from the storage capture.
C.The primary namespace messages are permanently deleted and cannot be recovered.
D.Messages remaining in the primary namespace are not automatically replicated to the secondary namespace; failover relies on metadata synchronization.
AnswerD

Service Bus geo-disaster recovery replicates namespace metadata only; message bodies and subscription state stay in the primary namespace. After failover, unprocessed messages there are inaccessible, so the secondary starts empty — matching the stem's failover scenario.

Why this answer

Service Bus geo-disaster recovery (Geo-DR) pairs a primary and secondary namespace and continuously replicates only the namespace metadata — queues, topics, subscriptions, filters, and authorization rules. Message data itself is not replicated, so messages sitting in the primary namespace's subscriptions at the moment of failover are not available in the secondary namespace and are effectively stranded until the primary is restored.

Exam trap

AI-200 often tests the misconception that Service Bus Geo-DR replicates messages, when in fact it only replicates metadata — candidates who assume full data replication pick the wrong option.

How to eliminate wrong answers

Option A is wrong because Service Bus Geo-DR does not perform automatic message migration; there is no 5-second replication of queued messages. Option B is wrong because Event Grid capture/replay is unrelated to Service Bus Geo-DR and cannot recover Service Bus messages. Option C is wrong because the messages are not necessarily permanently deleted — they remain in the primary namespace and can be recovered if the primary region comes back, but they are not available in the secondary after failover.

Practice this question →
73
MCQhard

You are developing a real-time AI sentiment analysis pipeline using Azure Event Hubs. The pipeline ingests customer feedback messages at a high rate. You need to ensure that each message is processed exactly once by the downstream analytics service, even if the service experiences transient failures. The analytics service uses the EventProcessorClient in the Azure.Messaging.EventHubs library. Which approach should you implement?

A.Enable the 'EnableCheckpointing' property on the EventProcessorClient and store checkpoints in an Azure Storage account.
B.Use the EventProcessorClient with a ProcessEventAsync handler that performs processing and then updates the checkpoint in the same transaction.
C.Implement idempotent processing logic in the downstream service and use checkpointing to minimize reprocessing.
D.Set the 'MaximumWaitTime' property to zero to ensure immediate checkpointing after each event.
AnswerC

Exactly-once processing in Event Hubs is not natively supported. The recommended approach is to design idempotent consumers that can handle duplicate messages without adverse effects, combined with checkpointing to reduce the window of reprocessing. This ensures that even if a message is processed more than once, the result is the same as if it were processed once.

Why this answer

Azure Event Hubs provides at-least-once delivery semantics. To achieve exactly-once processing end-to-end, the consumer must be idempotent. Checkpointing helps reduce duplicate processing but cannot eliminate it entirely because a failure can occur after processing but before checkpointing.

Therefore, combining idempotent logic with checkpointing is the correct strategy to meet the requirement.

Exam trap

The trap here is believing that checkpointing alone guarantees exactly-once processing, when it actually provides at-least-once with reduced duplicates.

Practice this question →
74
Multi-Selectmedium

You are designing an enterprise event-driven architecture for AI workloads. Which TWO Azure services provide native support for publishing discrete, reactive event notifications when resources are created or modified? Each correct answer represents a complete solution.

Select 2 answers
A.Azure Notification Hubs
B.Azure Blob Storage (native event notifications)
C.Azure Event Grid
D.Azure Event Hubs
E.Azure Service Bus Queues
AnswersB, C

Blob Storage emits native event notifications when blobs are created, modified or deleted, pushing discrete reactive payloads without polling. This satisfies the stem's demand for native publication of resource-change events, and these notifications can be routed onward to subscribers such as Azure Functions or Event Grid.

Why this answer

Azure Blob Storage natively supports event notifications that fire discrete, reactive events such as Microsoft.Storage.BlobCreated and Microsoft.Storage.BlobDeleted when blobs are created or modified, which fits the requirement for resource-change notifications. Azure Event Grid is a fully managed publish-subscribe eventing service that natively delivers discrete, reactive event notifications from Azure resources (including Blob Storage) to subscribers via event subscriptions, making it the canonical service for this scenario. Azure Notification Hubs is a push-notification service for mobile/consumer devices (APNs, FCM, WNS), not a resource-event publisher.

Azure Event Hubs is a big-data streaming/telemetry ingestion service (high-throughput event streaming), not a discrete resource-change notification publisher. Azure Service Bus Queues are a brokered messaging construct for commands/messages with queuing semantics, not native resource event notifications.

Exam trap

AI-200 often tests the distinction between reactive event notification services (Event Grid, Blob Storage events) and streaming/messaging services (Event Hubs, Service Bus), causing candidates to select Event Hubs for discrete notifications.

Practice this question →
75
Multi-Selectmedium

You are architecting an asynchronous machine learning inference pipeline. Which TWO Azure services allow you to decouple event publishers from event consumers using a publish-subscribe (pub/sub) pattern? Each correct answer represents a valid pub/sub architecture service.

Select 2 answers
A.Azure Event Grid
B.Azure Notification Hubs
C.Azure Storage Queues
D.Azure Event Hubs Capture
E.Azure Service Bus Topics
AnswersA, E

Azure Event Grid is a fully managed event-routing service built on pub/sub, letting publishers emit events to topics while subscribers receive them through subscriptions. This decouples producers from consumers, satisfying the stem's requirement for an asynchronous pub/sub service in the inference pipeline.

Why this answer

Azure Event Grid (A) is correct because it is a fully managed event-routing service that implements the pub/sub pattern: publishers emit events to topics and multiple subscribers receive them via event subscriptions with filters, enabling full decoupling of producers and consumers. Azure Service Bus Topics (E) is correct because a topic supports the publish-subscribe model where each subscriber creates its own subscription and receives a copy of every message, providing decoupled, asynchronous delivery with features like filters and sessions. Azure Notification Hubs (B) is a push-notification broadcast service for mobile devices, not a general event pub/sub backbone for decoupling publishers and consumers.

Azure Storage Queues (C) implements point-to-point queue messaging where each message is consumed by a single receiver, not a fan-out pub/sub pattern. Azure Event Hubs Capture (D) is a feature that automatically persists streaming data to Blob Storage or Data Lake, not a pub/sub decoupling service.

Exam trap

AI-200 often tests the difference between true pub/sub (Event Grid, Service Bus Topics) and point-to-point queues (Storage Queues) or push-notification services (Notification Hubs) — candidates who treat all messaging services as pub/sub pick Storage Queues incorrectly.

Practice this question →
Page 1 of 2 · 100 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Event Driven Integration questions.

Start 20-question session
CCNA Event Driven Integration Questions — Page 1 of 2 | Courseiva