Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) AI-200 Questions 301–375 | Page 5/6

301

MCQeasy

Which REST API HTTP method is used to create or update an index definition in Azure AI Search?

A.GET

B.PUT

C.PATCH

D.DELETE

AnswerB

PUT is idempotent, so repeated calls create or fully replace the index definition at the specified URI without duplicating resources. POST would create a new index each time, failing the create-or-update requirement, while PATCH performs partial updates only.

Why this answer

Azure AI Search exposes index definitions through its REST API at /indexes/{indexName}, and creating or replacing an index definition uses HTTP PUT. PUT is idempotent and replaces the entire index definition, which is the documented method for creating or updating an index. GET retrieves, PATCH is not supported for index definitions, and DELETE removes the index.

Exam trap

AI-200 often tests whether candidates assume PATCH is available for partial index updates, when Azure AI Search requires PUT with the complete definition.

How to eliminate wrong answers

Option A is wrong because GET only retrieves an existing index definition and cannot create or update one. Option C is wrong because Azure AI Search does not support PATCH for index definitions; partial updates are not available via PATCH on the indexes endpoint. Option D is wrong because DELETE removes an index and does not create or update it.

Full explanation →

302

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.

Full explanation →

303

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.

Full explanation →

304

MCQmedium

You are implementing a RAG solution where user queries are matched against an Azure AI Search vector index. You want to ensure that search results only return documents where a specific metadata field 'securityLevel' matches the user's clearance. How should you apply this filter?

A.Pass an OData filter expression in the 'filter' parameter of the search query request

B.Create a separate Azure AI Search service for each security level

C.Encode the security level into the vector embedding values directly

D.Filter the results in application memory after receiving all 1000 documents

AnswerA

The OData filter expression is evaluated against the index's filterable fields, restricting the candidate set to documents whose securityLevel matches the user's clearance before results are returned. This enforces per-user authorisation at query time without altering the vector similarity computation.

Why this answer

Passing an OData filter expression in the 'filter' parameter of the search query request is the correct way to restrict results by metadata such as securityLevel. Azure AI Search supports OData filter syntax on filterable fields, and the filter is applied alongside vector search to return only documents matching the predicate. This enforces security trimming at query time without duplicating services or embedding metadata into vectors.

Exam trap

AI-200 often tests the misconception that security filtering should be done in application code or by embedding metadata in vectors, when the correct approach is server-side OData filtering on filterable fields.

How to eliminate wrong answers

Option B is wrong because creating a separate search service per security level is costly, operationally complex, and does not scale; it also duplicates indexes and data unnecessarily. Option C is wrong because encoding security level into vector embedding values is not a reliable filtering mechanism; embeddings are semantic representations, and you cannot deterministically filter on embedded metadata values, nor does it enforce access control. Option D is wrong because filtering in application memory after retrieving all 1000 documents is inefficient, exposes unauthorized documents to the application, and does not scale; it also defeats the purpose of server-side filtering and can leak data.

Full explanation →

305

MCQhard

You are integrating Azure Container Registry with Azure Kubernetes Service. You want to enable authentication without storing static credentials (username/password) in Kubernetes secrets. What is the recommended integration method?

A.Store ACR admin credentials in a Kubernetes Secret object

B.Configure a Docker daemon config.json file on every node manually

C.Attach the ACR to the AKS cluster using Azure CLI attachment command

D.Enable anonymous pull on the Azure Container Registry

AnswerC

Attaching the registry with the Azure CLI attachment command configures the AKS kubelet identity with the AcrPull role assignment, so nodes pull images using managed identity tokens. This satisfies the no-static-credentials constraint, unlike imagePullSecrets or admin account keys.

Why this answer

Attaching ACR to AKS using the Azure CLI (az aks update --attach-acr) configures the cluster's kubelet managed identity with the AcrPull role on the registry, enabling image pulls without static credentials. This is the native, supported integration that eliminates the need for Kubernetes image pull secrets.

Exam trap

AI-200 often tests whether candidates know that AKS-ACR integration uses managed identity and RBAC (AcrPull) rather than Kubernetes secrets, tempting them to pick the familiar imagePullSecret pattern.

How to eliminate wrong answers

Option A is wrong because storing ACR admin credentials in a Kubernetes Secret reintroduces static credentials, which the scenario explicitly wants to avoid, and admin credentials are all-or-nothing. Option B is wrong because manually configuring a Docker config.json on every node is operationally fragile, does not survive node scaling, and still embeds credentials. Option D is wrong because anonymous pull makes the registry publicly readable, which is a security risk and not an authentication integration.

Full explanation →

306

MCQmedium

You have an AI scoring script that runs periodically. You want to execute this containerized workload on a schedule without managing virtual machines. Which Azure service is best suited for running containerized batch jobs on a schedule?

A.Azure Kubernetes Service CronJobs

B.Azure Container Instances with restart policy Always

C.Azure Functions with HTTP triggers

D.Azure Container Apps Jobs

AnswerD

Azure Container Apps Jobs runs containerised tasks on cron or event triggers with no VM or cluster management, satisfying the scheduled batch requirement. Unlike plain Container Apps, Jobs are designed for run-to-completion workloads rather than long-running services.

Why this answer

Azure Container Apps Jobs is correct because it is a serverless container execution service that supports scheduled (cron) and event-driven jobs without managing VMs or Kubernetes infrastructure. You define a container image, a cron schedule, and resource limits, and Azure handles the orchestration, scaling, and execution — ideal for periodic AI scoring scripts packaged as containers.

Exam trap

AI-200 often tests the confusion between AKS CronJobs and Container Apps Jobs — candidates pick AKS because 'CronJob' sounds purpose-built, ignoring the requirement to avoid managing VMs and infrastructure.

How to eliminate wrong answers

Option A is wrong because AKS CronJobs require you to provision, manage, and pay for an AKS cluster (nodes, upgrades, networking) — the question explicitly asks to avoid managing VMs, and AKS is a heavier operational burden. Option B is wrong because Azure Container Instances with restart policy 'Always' runs a container continuously and restarts it on exit; it is not a scheduling mechanism and would run the job perpetually rather than on a schedule. Option C is wrong because Azure Functions with HTTP triggers execute on HTTP requests, not on a schedule, and are code-first (not containerized batch jobs by default); a Timer trigger would be needed for scheduling, and Functions is not the best fit for arbitrary containerized batch workloads.

Full explanation →

307

MCQmedium

You are deploying a containerized AI inference API to Azure Container Apps. The container must read model files from an Azure Files share and write temporary logs to the same share. You need to configure the Container App so the share is available at a specific mount path inside the container. What should you do?

A.Configure an Azure File share as a bind mount by adding it to the Dockerfile VOLUME instruction.

B.Use the Azure CLI command az containerapp storage add to mount the share into the running container instance.

C.Attach the Azure Files share directly to the Container App using the Azure portal's 'Networking' blade.

D.Create an Azure Files storage definition in the Container Apps environment and add a volume mount to the Container App revision.

AnswerD

Azure Container Apps supports mounting Azure Files shares by defining a storage resource at the environment level and then referencing it as a volume with a mount path in the container app. This makes the share available to the container at the specified path, allowing the AI workload to read model files and write logs persistently across revisions.

Why this answer

To make an Azure Files share available to a Container App, you must first define the storage at the Container Apps environment level, then reference it as a volume and specify a mount path in the container app revision. This enables the AI workload to persist model files and logs. Other options either refer to non-existent features or confuse container-local volumes with external Azure Files mounts.

Exam trap

The trap here is assuming that Dockerfile VOLUME instructions or portal networking settings can mount an external Azure Files share, when Azure Container Apps requires environment-level storage definitions and volume mounts.

Full explanation →

308

MCQhard

You are configuring a vector index in Azure AI Search and want to apply scalar quantization to reduce the memory footprint. What is the primary effect of scalar quantization on float32 vector data?

A.It increases vector dimensions from 1536 to 3072 to improve accuracy

B.It eliminates the need for an HNSW graph structure

C.It converts vectors into plain text strings for keyword indexing

D.It compresses float32 vectors to int8 integers, reducing memory usage by approximately 75%

AnswerD

Scalar quantization maps each float32 component to an int8 value, cutting storage from 32 bits to 8 bits per dimension. That four-to-one reduction lowers vector memory footprint by roughly 75%, while retaining the original vectors for rescoring.

Why this answer

Scalar quantization in Azure AI Search compresses each float32 component of a vector into an 8-bit integer (int8), reducing storage from 4 bytes to 1 byte per dimension — roughly a 75% memory reduction. This allows larger vector indexes to fit in memory and lowers cost, with only a small recall degradation that is typically acceptable for most RAG workloads.

Exam trap

AI-200 often tests the misconception that quantization improves accuracy or changes the ANN algorithm — in reality it trades a small amount of recall for large memory savings while keeping the same HNSW structure.

How to eliminate wrong answers

Option A is wrong because quantization reduces precision, not increases dimensionality — increasing dimensions would increase memory, the opposite of the goal. Option B is wrong because scalar quantization is orthogonal to the HNSW graph; HNSW is still used as the approximate nearest neighbor algorithm, and quantized vectors are stored in the graph nodes. Option C is wrong because quantization keeps vectors as numeric arrays; converting to text would defeat vector similarity search entirely and is not what quantization does.

Full explanation →

309

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.

Full explanation →

310

Multi-Selectmedium

To optimize costs and monitor consumption for an Azure OpenAI deployment across multiple business units, which THREE practices should you implement? (Choose three)

Select 3 answers

A.Apply Azure resource tags representing cost centers or business units to all AI service instances.

B.Delete all Log Analytics diagnostic logs immediately upon generation to reduce storage billing.

C.Analyze token usage patterns using Azure Monitor metrics to evaluate switching between Provisioned Throughput and Pay-As-You-Go.

D.Provision maximum possible provisioned throughput units permanently regardless of active workload.

E.Set up Azure Budgets with alert actions to notify department heads when spending hits 80% of allocation.

AnswersA, C, E

Resource tags propagate to Azure cost management, letting consumption be grouped and reported by business unit or cost centre. This satisfies the stem's multi-business-unit monitoring requirement, since untagged resources cannot be attributed to a department.

Why this answer

Option A is correct because applying Azure resource tags that represent cost centers or business units to every AI service instance enables cost allocation and chargeback reporting in Azure Cost Management, which is essential for tracking consumption per business unit. Option C is correct because Azure Monitor exposes token usage metrics for Azure OpenAI, and analyzing those patterns lets you decide whether Provisioned Throughput Units (PTUs) or Pay-As-You-Go token billing is cheaper for each workload's utilization profile. Option E is correct because Azure Budgets support alert actions (email, action groups, automation) that notify department heads when actual or forecasted spend reaches a threshold such as 80% of allocation, enabling proactive cost control.

Option B is wrong because deleting Log Analytics diagnostic logs immediately destroys the telemetry needed for monitoring and auditing, and diagnostic logs are not the primary driver of Azure OpenAI cost. Option D is wrong because permanently provisioning maximum PTUs regardless of active workload wastes money, since PTUs are billed hourly whether or not they are used.

Exam trap

AI-200 often tests the false-economy trap — candidates pick 'delete logs to save money' or 'provision max PTU for safety' when the correct answers balance observability, right-sizing, and proactive alerting.

Full explanation →

311

MCQmedium

You have an AI model container hosted in Azure Container Registry. You want to ensure that every container image pushed to the registry is automatically scanned for known vulnerabilities before deployment. Which ACR feature should you enable?

A.ACR Tasks auto-purge

B.Content Trust

C.ACR geo-replication

D.Microsoft Defender for Cloud vulnerability scanning

AnswerD

Defender for Cloud's registry integration scans images on push, surfacing OS and language-package vulnerabilities per digest. Enabling it satisfies the requirement that every pushed image is automatically assessed before deployment, without altering the build pipeline.

Why this answer

Microsoft Defender for Cloud vulnerability scanning is correct because it provides integrated image vulnerability assessment for Azure Container Registry, automatically scanning images on push and continuously re-scanning for newly disclosed CVEs. Enabling the Defender for Containers plan surfaces scan results in Defender for Cloud and can gate deployments via Azure Policy. This directly satisfies the requirement to scan every pushed image before deployment.

Exam trap

AI-200 often tests the confusion between registry security features — candidates pick Content Trust thinking 'security' means scanning, when Content Trust only handles image signing and integrity, not CVE detection.

How to eliminate wrong answers

Option A is wrong because ACR Tasks auto-purge is a retention/cleanup feature that deletes old or untagged images based on a schedule or count — it has nothing to do with vulnerability scanning. Option B is wrong because Content Trust (Docker Content Trust/Notary) enforces image signing and verification so only signed images can be pulled; it ensures integrity and provenance but does not detect vulnerabilities. Option C is wrong because ACR geo-replication replicates a registry across multiple Azure regions for latency and availability — it is a distribution feature, not a security scanning feature.

Full explanation →

312

MCQhard

You are running a containerized AI inference service on Azure Kubernetes Service (AKS). The service uses a large language model and requires 24 GB of GPU memory. You have a node pool with NVIDIA V100 GPUs (16 GB each). You need to ensure the pod can access sufficient GPU memory. What should you do?

A.Configure the pod to request `nvidia.com/gpu: 2` in its resource limits.

B.Increase the memory limit of the pod to 24 GB and set the `NVIDIA_VISIBLE_DEVICES` environment variable to `all`.

C.Enable GPU sharing by setting the `nvidia.com/gpu` resource to `0.5` to allow two pods to share a GPU.

D.Use a node pool with GPUs that have at least 24 GB of memory, such as NVIDIA A100 (40 GB) or V100 (32 GB), and request one GPU.

AnswerD

The inference service requires 24 GB of GPU memory. To meet this, you need a GPU with at least 24 GB of memory per device. NVIDIA A100 (40 GB) or V100 (32 GB) satisfy this. Requesting one GPU from such a node pool ensures the pod gets a single GPU with sufficient memory, which is the simplest and most reliable solution.

Why this answer

The inference service requires 24 GB of GPU memory. The existing V100 GPUs have only 16 GB, so a single GPU is insufficient. The correct approach is to use a node pool with GPUs that have at least 24 GB, such as A100 (40 GB) or V100 (32 GB), and request one GPU.

This provides the necessary memory without requiring multi-GPU programming.

Exam trap

The trap here is assuming that requesting multiple GPUs or increasing pod memory limits will provide more GPU memory to a single container, when GPU memory is per-device.

Full explanation →

313

Multi-Selecthard

You are designing a big data telemetry ingestion pipeline using Azure Event Hubs. Which THREE configuration options or properties must you consider when planning Event Hubs capacity and scaling? (Choose three)

Select 3 answers

A.Partition Count

B.Service Bus Lock Duration

C.Event Grid Webhook Handshake Timeout

D.Throughput Units (TUs) or Processing Units (PUs)

E.Message Retention Period

AnswersA, D, E

Partition count sets the maximum throughput unit for an event hub and cannot be changed after creation, so it directly governs ingest scale and consumer parallelism. Planning capacity requires fixing it upfront to satisfy the pipeline's telemetry throughput and scaling constraints.

Why this answer

Partition Count (A) is correct because partitions are the fundamental unit of scale and parallelism in Event Hubs; the number of partitions determines the maximum concurrent readers per consumer group and directly caps ingress/egress throughput, so it must be planned up front since it cannot be reduced after creation. Throughput Units (TUs) or Processing Units (PUs) (D) are correct because they define the provisioned capacity of the namespace (TUs for Standard/Dedicated, PUs for Premium), governing ingress (e.g., 1 MB/s per TU) and egress limits and enabling auto-inflate scaling. Message Retention Period (E) is correct because it determines how long events remain available in the partition stream (1–7 days Standard, up to 90 days Premium/Dedicated), which affects storage consumption, replay/recovery windows, and downstream checkpointing design.

Service Bus Lock Duration (B) is incorrect because it is a Service Bus queue/subscription peek-lock setting, not an Event Hubs property. Event Grid Webhook Handshake Timeout (C) is incorrect because it belongs to Event Grid event subscription delivery validation, not Event Hubs capacity planning.

Exam trap

AI-200 often tests the confusion between Event Hubs and Service Bus properties — candidates pick 'Lock Duration' because it sounds like a scaling knob, but it belongs to Service Bus, not Event Hubs.

Full explanation →

314

MCQeasy

Your application publishes custom events to an Azure Event Grid topic. You want to ensure that event publishers transmit data over secure HTTPS endpoints only. How should you enforce this?

A.You must install a self-signed SSL certificate on the publisher client machine.

B.Event Grid enforces HTTPS by default for all custom topic publishing endpoints.

C.Configure an Azure Firewall rule allowing port 80 outbound.

D.You must configure an Azure Application Gateway in front of the Event Grid topic.

AnswerB

Event Grid custom topics accept publisher traffic only over TLS 1.2+ HTTPS endpoints; plain HTTP requests are rejected outright, so no extra configuration is needed to satisfy the stem's secure-transport constraint. This default enforcement means publishers cannot transmit event data unencrypted, meeting the requirement without custom domain or firewall changes.

Why this answer

Azure Event Grid custom topics expose a publishing endpoint that only accepts HTTPS (TLS 1.2+) requests — there is no HTTP listener. Publishers must POST events to the topic's HTTPS URL using the `aeg-sas-key` header or Microsoft Entra ID token. Because HTTPS is the only supported transport, no additional configuration (certificates, firewalls, or gateways) is required to enforce it.

Exam trap

AI-200 often tests the misconception that Azure services require you to manually enable or configure HTTPS, when in fact Event Grid (like most Azure PaaS endpoints) enforces HTTPS by default and offers no HTTP option.

How to eliminate wrong answers

Option A is wrong because Event Grid uses a Microsoft-managed TLS certificate on its endpoint; publishers never install certificates on client machines — they simply trust the public CA chain. Option C is wrong because opening port 80 outbound would enable HTTP traffic, which Event Grid does not accept anyway; the publishing endpoint does not listen on port 80. Option D is wrong because Application Gateway is a reverse proxy/load balancer for your own backends, not a prerequisite for Event Grid's built-in HTTPS enforcement — Event Grid terminates TLS itself.

Full explanation →

315

MCQhard

You are configuring a Vector Index in Azure AI Search. You need to ensure that the vector similarity search is performed using the Cosine distance metric. Where is this configuration specified?

A.In the indexer definition.

B.In the 'vectorSearch' section of the index definition.

C.In the search query payload.

D.In the field definitions within the index.

AnswerB

The vectorSearch object within the Azure AI Search index definition holds algorithm configurations, including the metric parameter where cosine is selected. Specifying it there binds the distance metric to the vector profile used by searchable vector fields.

Why this answer

In Azure AI Search, the vector search configuration, including the similarity metric such as cosine, dotProduct, or euclidean, is specified in the 'vectorSearch' section of the index definition. This section defines algorithms (like HNSW) and profiles that bind the metric to vector fields. The metric is set at the algorithm level and referenced by vector fields.

Exam trap

AI-200 often tests the misconception that the distance metric is set per query or per field, when it is actually defined in the vectorSearch algorithms section of the index.

How to eliminate wrong answers

Option A is wrong because the indexer definition controls data ingestion and field mappings, not vector similarity metrics. Option C is wrong because the search query payload specifies the query vector and parameters like k, but not the distance metric, which is fixed at index time. Option D is wrong because field definitions declare the vector field and its dimensions and profile reference, but the actual metric is defined in the vectorSearch algorithms section, not in the field itself.

Full explanation →

316

MCQhard

You are designing an Azure Cosmos DB for NoSQL container to store vector embeddings for a product recommendation engine. Queries will filter on category and then perform vector similarity search. You need to minimize latency and ensure the index supports both operations efficiently. Which indexing policy should you implement?

A.Exclude all paths except the vector property and create a vector index on it.

B.Include the category path in the range index and define a vector index on the embedding property.

C.Use only the default indexing policy, which automatically indexes all properties including vectors.

D.Create a composite index on category and the vector property.

AnswerB

Including the category path in the range index allows efficient filtering, and defining a vector index on the embedding property enables vector similarity search. This combination supports hybrid queries where the filter is applied first, reducing the candidate set for vector search, which minimizes latency and resource consumption. It is the recommended indexing strategy for filtered vector search in Cosmos DB for NoSQL.

Why this answer

For hybrid queries that filter on a scalar property and then perform vector search, the indexing policy must include the scalar property in the range index and define a vector index on the embedding property. This allows the query engine to apply the filter first, reducing the set of documents for vector comparison, which improves performance and lowers RU costs.

Exam trap

The trap here is assuming that indexing all properties by default also covers vector search, when vector indexes require explicit configuration.

Full explanation →

317

Multi-Selecthard

You are troubleshooting a scenario where hybrid queries in Azure AI Search are returning unexpected relevance rankings. Which THREE factors could influence the final score when using hybrid search with semantic ranking? (Choose three)

Select 3 answers

A.Virtual machine CPU core count assigned to the client application

B.Semantic ranker deep learning re-scoring

C.BM25 keyword match relevance scores

D.Reciprocal Rank Fusion (RRF) score combination weights

E.Azure Blob Storage container access tier (Hot vs Cool)

AnswersB, C, D

The semantic ranker applies deep learning re-scoring over the top results returned by the fused ranking, so its presence and configuration directly alter final relevance order. This re-scoring layer operates after RRF, meaning its model output can override the earlier lexical and vector ordering.

Why this answer

Option B is correct because in hybrid search with semantic ranking, the semantic ranker applies deep learning models to re-score the top results returned by the initial retrieval, directly influencing the final relevance ranking. Option C is correct because hybrid search combines keyword-based BM25 scoring with vector similarity, so the BM25 keyword match relevance scores contribute to the fused ranking. Option D is correct because Reciprocal Rank Fusion (RRF) is the algorithm Azure AI Search uses to merge keyword and vector result sets, and its rank-based combination determines the fused score that feeds into semantic re-ranking.

Option A is incorrect because the CPU core count of the client application has no bearing on how Azure AI Search computes relevance scores server-side. Option E is incorrect because Blob Storage access tiers affect storage cost and latency, not the relevance scoring pipeline of a search index.

Exam trap

AI-200 often tests the misconception that infrastructure factors like VM size or storage tier affect search relevance, when only BM25, RRF, and semantic ranking do.

Full explanation →

318

MCQhard

You are designing an AI streaming pipeline using Azure Event Hubs with Apache Kafka enabled. Existing Java producers using the Kafka producer API need to authenticate against Event Hubs securely using Microsoft Entra ID (OAuth 2.0). How should you configure the Kafka producer client properties?

A.Use plain text authentication with the Event Hub root SAS key as the username and password.

B.Deploy an Event Grid webhook proxy between the Kafka producer and Event Hubs.

C.Set the bootstrap.servers property to the Service Bus AMQP connection string.

D.Configure security.protocol=SASL_SSL, sasl.mechanism=OAUTHBEARER, and implement an OAuthBearerTokenCallbackHandler for Microsoft Entra ID token acquisition.

AnswerD

Configuring `security.protocol=SASL_SSL` with `sasl.mechanism=OAUTHBEARER` satisfies the stem's Microsoft Entra ID requirement, since Event Hubs' Kafka endpoint accepts OAuth 2.0 tokens over SASL. The callback handler supplies fresh bearer tokens to the Java producer, replacing connection-string SASL/PLAIN authentication without altering existing producer code.

Why this answer

The correct configuration is to set security.protocol=SASL_SSL, sasl.mechanism=OAUTHBEARER, and implement an OAuthBearerTokenCallbackHandler for Microsoft Entra ID token acquisition. Azure Event Hubs with Kafka enabled supports OAuth 2.0 authentication via SASL/SSL. The Kafka producer must be configured to use SASL_SSL and the OAUTHBEARER mechanism, and the callback handler must obtain a token from Microsoft Entra ID (formerly Azure AD) and present it to Event Hubs.

Exam trap

AI-200 often tests the confusion between SAS key authentication and OAuth 2.0 for Kafka-enabled Event Hubs, leading candidates to choose plain text SAS or incorrect protocol settings.

How to eliminate wrong answers

Option A is wrong because using plain text authentication with the Event Hub root SAS key is insecure and does not use Microsoft Entra ID; it also transmits credentials in plain text. Option B is wrong because deploying an Event Grid webhook proxy is unnecessary and does not provide authentication; Event Grid is for event routing, not for proxying Kafka connections. Option C is wrong because setting the bootstrap.servers property to the Service Bus AMQP connection string is incorrect; Event Hubs Kafka endpoint uses a different hostname (e.g., <namespace>.servicebus.windows.net:9093) and AMQP is not used for Kafka protocol.

Full explanation →

319

Multi-Selectmedium

Your development team is implementing an event-driven microservices architecture using Azure Service Bus. You need to ensure strict FIFO (First-In, First-Out) message processing order for related financial transaction events in an AI fraud-detection workflow. Which THREE configuration steps are required? (Choose three)

Select 3 answers

A.Implement a MessageSession receiver in your client application to process messages sequentially per session.

B.Set a Session ID on all related messages sent to the queue.

C.Configure partitioning on the Service Bus namespace tier.

D.Enable sessions on the Azure Service Bus queue.

E.Enable duplicate detection with a 10-minute history window.

AnswersA, B, D

A MessageSession receiver accepts a session lock and processes its messages one at a time, preserving order. Without this sequential per-session consumption pattern, even session-enabled queues could be drained concurrently, breaking the FIFO requirement for financial events.

Why this answer

Option D is correct because sessions must be explicitly enabled on the Service Bus queue (via the EnableSession property) before session-based FIFO ordering can be used; without this, session IDs are ignored. Option B is correct because setting a Session ID on all related financial transaction messages groups them into the same session, guaranteeing that messages with the same SessionId are delivered in order. Option A is correct because the receiving client must use a MessageSession receiver (via AcceptMessageSessionAsync) to process each session's messages sequentially and in FIFO order.

Option C is not required because partitioning is a throughput/availability feature and does not provide FIFO ordering; in fact, partitioned entities without sessions do not guarantee ordering. Option E is not required because duplicate detection only prevents duplicate message submission within the history window and has no role in enforcing FIFO processing order.

Exam trap

AI-200 often tests whether candidates confuse duplicate detection (deduplication) with sessions (FIFO ordering) — candidates pick duplicate detection thinking it enforces order, when only sessions provide FIFO guarantees.

Full explanation →

320

MCQeasy

Your AI ingestion pipeline ingests millions of clickstream events per second from IoT devices and streams them into an Azure ML training pipeline. Which Azure service is specifically designed for high-throughput, low-latency telemetry ingestion at this scale?

A.Azure Notification Hubs

B.Azure Event Hubs

C.Azure Event Grid

D.Azure Service Bus Queues

AnswerB

Azure Event Hubs is a partitioned event-ingestion service built for millions of events per second with low latency, buffering telemetry before downstream consumption, which matches the clickstream ingestion requirement far better than batch-oriented storage services.

Why this answer

Azure Event Hubs is designed for high-throughput, low-latency ingestion of telemetry data, capable of handling millions of events per second. It is optimized for streaming scenarios like IoT telemetry and clickstream data, making it ideal for this use case.

Exam trap

AI-200 often tests the confusion between Event Hubs (high-throughput streaming) and Service Bus (enterprise messaging with transactions), or Event Grid (event routing). Candidates may pick Service Bus due to its reliability features, but the scale requirement points to Event Hubs.

How to eliminate wrong answers

Option A is wrong because Azure Notification Hubs is for sending push notifications to mobile devices, not for high-volume telemetry ingestion. Option C is wrong because Azure Event Grid is for event routing and reactive programming, not for high-throughput streaming. Option D is wrong because Azure Service Bus Queues are for enterprise messaging with guaranteed delivery, but not designed for millions of events per second.

Full explanation →

321

MCQmedium

You are developing a RAG solution and need to evaluate the quality of your vector retrieval results from Azure AI Search. Which metric is commonly used to measure the proportion of relevant documents retrieved in the top-k results?

A.HNSW efSearch latency

B.Request Units per second (RU/s)

C.BM25 term frequency

D.Recall@k

AnswerD

Recall@k measures the proportion of all relevant documents that appear within the top-k retrieved results, directly matching the stated evaluation goal. It differs from precision@k, which instead measures how many retrieved documents are relevant, so recall@k satisfies the retrieval-quality constraint.

Why this answer

Recall@k is the metric that measures the proportion of relevant documents retrieved in the top-k results. It is defined as the number of relevant documents retrieved in the top-k divided by the total number of relevant documents available. This metric is widely used in information retrieval and RAG evaluation to assess retrieval quality.

Exam trap

AI-200 often tests the distinction between retrieval quality metrics (like recall@k) and performance metrics (like latency or RU/s). Candidates might confuse recall@k with precision or other metrics, or mistakenly choose a performance-related option.

How to eliminate wrong answers

Option A is wrong because HNSW efSearch latency is a performance metric for the HNSW algorithm, not a retrieval quality metric. Option B is wrong because Request Units per second (RU/s) is a throughput metric for Cosmos DB, not for Azure AI Search. Option C is wrong because BM25 term frequency is a component of the BM25 ranking algorithm, not a metric for evaluating retrieval results.

Full explanation →

322

MCQeasy

When configuring an Azure Cosmos DB for NoSQL container to store embeddings, what data type must the vector property be stored as within the JSON document?

A.A base64 encoded string

B.An array of integers

C.An array of 32-bit floating-point numbers

D.A binary blob

AnswerC

Azure Cosmos DB for NoSQL stores vector embeddings as a JSON array of 32-bit floating-point numbers, matching the VectorDistance system function's expected input. This satisfies the stem's requirement that the vector property be a native JSON array, since Cosmos DB has no dedicated vector column type and rejects other numeric precisions.

Why this answer

Azure Cosmos DB for NoSQL stores vector embeddings as a JSON array of 32-bit floating-point numbers (float32), which is the format its native vector indexing and DiskANN-based similarity search expect. Each element represents one dimension of the embedding, and the container's vector policy declares dimensions and the float32 data type.

Exam trap

AI-200 often tests the misconception that embeddings can be stored as strings or integers, when Cosmos DB NoSQL requires a JSON array of float32 values matching the declared vector policy.

How to eliminate wrong answers

Option A is wrong because base64-encoded strings are not natively indexed or queried as vectors by Cosmos DB's vector search; they would require application-side decoding and cannot leverage the vector index. Option B is wrong because integer arrays lose the precision needed for embedding similarity — embeddings are inherently floating-point, and truncating to integers degrades recall. Option D is wrong because binary blobs are not a supported vector representation in the Cosmos DB NoSQL vector policy; the JSON document model requires an array of numbers.

Full explanation →

323

MCQmedium

You are deploying an Azure OpenAI Service resource and must ensure that all traffic from your virtual network reaches the endpoint without traversing the public internet. Which feature should you configure?

A.Enable public network access with selected IP address ranges

B.Configure a Service Endpoint without enabling virtual network rules

C.Deploy an Azure Application Gateway in front of the endpoint

D.Configure a Private Endpoint for the Azure OpenAI resource

AnswerD

A Private Endpoint assigns a private IP from your subnet to the Azure OpenAI resource via Azure Private Link, so virtual network traffic reaches the endpoint over the Microsoft backbone and never traverses the public internet, satisfying the stated constraint.

Why this answer

Private endpoints use private IP addresses from your VNet to securely bring services into your VNet, eliminating public exposure.

Full explanation →

324

MCQeasy

You are designing an application that stores vector embeddings in Azure SQL Database. Which data type should you use to store vector data natively in modern Azure SQL?

A.VARCHAR(MAX) JSON string

B.VECTOR native data type

C.FLOAT array collection

D.VARBINARY(MAX) blob

AnswerB

The VECTOR native data type stores embeddings directly in Azure SQL Database, satisfying the requirement for native vector storage. Unlike storing embeddings as JSON or VARBINARY, VECTOR enables efficient similarity searches and integrates with functions such as VECTOR_DISTANCE, avoiding manual serialisation and preserving dimensional semantics for AI workloads.

Why this answer

Modern Azure SQL Database and SQL Server 2025 introduce a native VECTOR data type that stores float32 arrays with declared dimensions, enabling native vector functions like VECTOR_DISTANCE and integration with vector indexes. This is the correct native type for storing embeddings in Azure SQL.

Exam trap

The trap is that VARCHAR(MAX) JSON and VARBINARY(MAX) are technically capable of holding vector data, so candidates pick them as 'good enough' — but the question asks for the native type, which is VECTOR.

How to eliminate wrong answers

Option A is wrong because storing vectors as a VARCHAR(MAX) JSON string works but is not native — it requires parsing and cannot use native vector functions or indexes efficiently. Option C is wrong because 'FLOAT array collection' is not a valid Azure SQL data type; SQL Server has no array type. Option D is wrong because VARBINARY(MAX) stores raw bytes but provides no vector semantics, distance functions, or indexing — you'd have to implement everything manually.

Full explanation →

325

MCQmedium

You need to ensure that all data sent to Azure OpenAI Service is encrypted at rest using a custom encryption key that your organization controls and rotates. Which feature must you configure?

A.Client-side encryption using PGP keys before sending HTTP payloads

B.Customer-managed keys (CMK) stored in Azure Key Vault

C.Azure Information Protection sensitivity labels applied via Microsoft Purview

D.Transparent Data Encryption (TDE) configured via SQL Server Management Studio

AnswerB

Customer-managed keys wrap the Azure OpenAI resource's data encryption key with a key held in Azure Key Vault, giving the organisation control over rotation. This satisfies the requirement that data at rest be encrypted with an organisation-controlled, rotatable key.

Why this answer

Customer-managed keys (CMK) in Azure Key Vault let you supply your own encryption key that Azure OpenAI uses for data-at-rest encryption, and you control rotation and revocation through Key Vault. This satisfies the requirement for organization-controlled, rotatable encryption keys for stored data.

Exam trap

AI-200 often tests the misconception that client-side encryption or Purview labels satisfy at-rest key control, when only CMK in Azure Key Vault gives the organization custody and rotation of the encryption key.

How to eliminate wrong answers

Option A is wrong because client-side PGP encryption protects data in transit or before storage but does not govern Azure OpenAI's at-rest encryption of stored data, and it is not a supported Azure OpenAI feature. Option C is wrong because Microsoft Purview sensitivity labels classify and protect documents but do not provide the encryption key for Azure OpenAI's at-rest storage. Option D is wrong because TDE is a SQL Server/Azure SQL feature and has no applicability to Azure OpenAI Service, which does not use SQL Server for its storage.

Full explanation →

326

MCQeasy

You need to restrict access to an Azure OpenAI resource so that only requests originating from a specific Azure Virtual Network are permitted. What should you configure?

A.Enable Cross-Origin Resource Sharing (CORS) and specify the VNet IP range.

B.Configure the Azure OpenAI resource networking settings to allow access from 'Selected networks' and add your Virtual Network subnet.

C.Assign the Cognitive Services Contributor role to the Virtual Network principal.

D.Enable Microsoft Defender for Cloud on the Virtual Network.

AnswerB

Selecting 'Selected networks' and adding the Virtual Network subnet applies service-level network ACLs, so requests from outside that subnet are rejected before reaching the model, satisfying the requirement to restrict access to one specific Azure Virtual Network.

Why this answer

Virtual network rules (service endpoints or private endpoints) on the Azure OpenAI firewall can restrict access to specific VNets.

Full explanation →

327

MCQmedium

You are building a RAG solution using Azure AI Search. Documents are updated frequently, and you need each document's vector embedding to be regenerated automatically whenever its text changes, without writing custom code to detect changes. Which Azure AI Search feature should you configure?

A.A synonym map that links text terms to their vector representations.

B.An indexer with a skillset that includes the Azure OpenAI Embedding skill.

C.A scoring profile that boosts documents with recently updated timestamps.

D.A custom Web API skill that calls Azure OpenAI directly and writes vectors to the index.

AnswerB

An indexer with an Azure OpenAI Embedding skill reads source documents, applies the embedding model, and writes vectors into the index. When combined with a change detection policy, it automatically reprocesses only changed documents, so embeddings stay current without custom code.

Why this answer

An indexer with the Azure OpenAI Embedding skill automatically chunks and vectorizes source content during indexing. When paired with a change detection policy (such as a high-water mark column or change tracking), only modified documents are reprocessed, keeping embeddings synchronized without custom code. This is the standard no-code approach for maintaining vector freshness in Azure AI Search.

Exam trap

The trap here is assuming that vector fields update automatically when source text changes, when in fact an indexer and change detection policy must be configured to regenerate embeddings.

Full explanation →

328

MCQhard

You are troubleshooting a latency issue with an AI model deployed in a Virtual Machine. You suspect the issue is related to storage IOPS limits. Which tool should you use to check the storage performance metrics?

A.Azure Network Watcher.

B.Azure Resource Graph Explorer.

C.Application Insights Dependency logs.

D.Azure Monitor Metrics for the Virtual Machine.

AnswerD

Azure Monitor Metrics exposes platform-level disk metrics for the virtual machine, including IOPS consumed, throughput and queue depth per data disk. This directly confirms whether storage IOPS throttling is causing the latency, which guest-level counters or application logs cannot attribute to the underlying limit.

Why this answer

Azure Monitor 'Metrics' for the Virtual Machine resource provides 'Disk Read Operations/sec' and 'Disk Write Operations/sec', which are key for diagnosing IOPS bottlenecks.

Full explanation →

329

MCQhard

You are designing a data layer architecture in Azure Cosmos DB for NoSQL for an AI application that performs high-frequency writes and real-time vector searches. You need to understand how vector indexing impacts write operations. What is the primary trade-off?

A.Vector properties cannot be updated after initial document creation

B.Writes are completely blocked until the vector index reaches 100% synchronization

C.Writing documents consumes more Request Units (RUs) because vector indexes must be updated

D.Writes require explicit distributed transactions across regions

AnswerC

Vector indexes must be updated on every insert, and each index write consumes additional Request Units beyond the document write itself. This directly satisfies the high-frequency write constraint: indexing overhead raises RU cost per operation, so write throughput is limited by provisioned RU budget.

Why this answer

Writing documents consumes more Request Units (RUs) because vector indexes must be updated on every write. In Azure Cosmos DB for NoSQL, vector indexing adds overhead to write operations since the index must be maintained as documents are inserted or updated. This is the primary trade-off: faster vector search at the cost of higher write RU consumption.

Exam trap

AI-200 often tests the misconception that vector indexing blocks writes or requires special transactions, when the real trade-off is increased RU consumption for index maintenance.

How to eliminate wrong answers

Option A is wrong because vector properties can be updated after document creation; Cosmos DB supports updating vector fields, and the index is updated accordingly, so this is not a limitation. Option B is wrong because writes are not completely blocked until the vector index reaches 100% synchronization; Cosmos DB uses eventual consistency for indexing, and writes proceed while indexing occurs asynchronously. Option D is wrong because writes do not require explicit distributed transactions across regions; Cosmos DB handles replication automatically, and vector indexing does not introduce a requirement for explicit distributed transactions.

Full explanation →

330

Multi-Selectmedium

When designing an event-driven architecture using Azure Event Grid, which THREE security or delivery mechanisms can be configured on an event subscription? Each correct answer represents a valid configuration option.

Select 3 answers

A.AMQP 1.0 broker transaction coordination

B.Advanced filtering based on event data property values

C.Dead-letter destination pointing to an Azure Blob Storage container

D.Service Bus session lock duration extension

E.Managed Identity for authenticating secure delivery to webhooks

AnswersB, C, E

Advanced filtering evaluates event payload properties against operators such as string comparisons and numeric ranges, so subscribers receive only matching events. This satisfies the stem's requirement for a configurable delivery mechanism on an Event Grid event subscription, reducing handler invocations and downstream processing costs.

Why this answer

Option B is correct because Event Grid event subscriptions support advanced filtering, which evaluates event data fields (such as string, number, boolean, and arrays) against operators like StringContains, NumberGreaterThan, and BoolEquals to route only matching events. Option C is correct because an event subscription can define a dead-letter destination, which must be an Azure Blob Storage container, where undeliverable events are stored along with a reason for delivery failure. Option E is correct because Event Grid supports using a managed identity (system-assigned or user-assigned) on the event subscription to authenticate delivery to supported destinations such as webhooks and Service Bus, avoiding embedded secrets.

Option A is not applicable because AMQP 1.0 broker transaction coordination is a Service Bus/AMQP messaging concept, not an Event Grid subscription setting. Option D is not applicable because Service Bus session lock duration is a Service Bus queue/subscription feature and cannot be configured on an Event Grid event subscription.

Exam trap

AI-200 often tests whether candidates can distinguish Event Grid subscription features (filtering, dead-letter, managed identity) from Service Bus features (sessions, AMQP transactions) that are irrelevant to Event Grid.

Full explanation →

331

MCQeasy

You are configuring an Azure AI Search vector index for a retrieval-augmented generation (RAG) application. You need to select an algorithm for vector similarity search that balances recall speed with accuracy while allowing approximate nearest neighbor (ANN) search. Which vector search algorithm configuration should you select?

A.Exhaustive K-Nearest Neighbor (exhaustiveKnn)

B.Hierarchical Navigable Small World (hnsw)

C.Locality-Sensitive Hashing (lsh)

D.Inverted File with Product Quantization (ivf-pq)

AnswerB

Hierarchical Navigable Small World (hnsw) builds a multi-layer proximity graph, enabling approximate nearest neighbour search that trades a small recall loss for markedly faster queries. It directly satisfies the stem's requirement for ANN search balancing recall speed with accuracy, unlike exhaustive k-nearest neighbour (knn), which guarantees exact results but scales linearly and cannot approximate.

Why this answer

Hierarchical Navigable Small World (hnsw) is the correct algorithm because it provides approximate nearest neighbor search with a tunable balance between recall and latency, using a multi-layer graph that enables fast traversal. Azure AI Search supports hnsw as a vector search algorithm configuration, and it is the recommended choice for RAG workloads that need low-latency, high-recall retrieval over large vector indexes. It directly satisfies the requirement for ANN with balanced speed and accuracy.

Exam trap

AI-200 often tests whether candidates recognize that Azure AI Search only exposes hnsw and exhaustiveKnn, tricking them into selecting ivf-pq or lsh because those are common in other vector databases.

How to eliminate wrong answers

Option A is wrong because exhaustiveKnn performs a brute-force scan of all vectors, which yields exact recall but scales poorly and is too slow for large indexes, so it does not balance speed with accuracy. Option C is wrong because Locality-Sensitive Hashing (lsh) is not a supported vector search algorithm configuration in Azure AI Search; it is a general ANN technique but not exposed as an index algorithm here. Option D is wrong because Inverted File with Product Quantization (ivf-pq) is not a native Azure AI Search algorithm configuration; while IVF and PQ are common in other vector databases, Azure AI Search exposes hnsw and exhaustiveKnn, not ivf-pq.

Full explanation →

332

MCQeasy

You want to limit the CPU resources that a specific AI inference pod can consume. Which Kubernetes field do you configure?

A.resources.requests.

B.securityContext.

C.resources.limits.

D.livenessProbe.

AnswerC

resources.limits caps the maximum CPU a container may consume, directly satisfying the requirement to limit a specific inference pod's CPU. It differs from resources.requests, which only reserves scheduling capacity and does not enforce an upper ceiling.

Why this answer

The `resources.limits` field in a Kubernetes pod spec sets the maximum CPU and memory a container can consume. When a container exceeds its CPU limit, it is throttled; when it exceeds its memory limit, it is OOM-killed. This is the correct field to cap CPU for an inference pod.

Exam trap

The trap is confusing requests with limits; AI-200 tests whether you know requests are for scheduling guarantees while limits enforce the maximum consumption ceiling.

How to eliminate wrong answers

Option A is wrong because `resources.requests` sets the minimum guaranteed resources for scheduling, not a maximum cap. Option B is wrong because `securityContext` defines privilege and access controls, not resource consumption. Option D is wrong because `livenessProbe` determines container health and restart behavior, not CPU limits.

Full explanation →

333

MCQmedium

Your AI application consumes messages from an Azure Service Bus queue. During peak hours, processing takes longer than expected, and messages are frequently locked out and redelivered prematurely. You want to increase the time a message remains locked by the receiver. Where should you configure this setting?

A.On the Azure Service Bus queue properties by modifying the LockDuration setting.

B.On the Event Grid subscription retry interval settings.

C.On the Event Hubs consumer group retention period.

D.In the Azure Function host.json file under the eventHubs retry policy.

AnswerA

LockDuration on the queue determines how long a receiver holds a message lock before it becomes visible again. Raising it prevents premature redelivery during peak processing, directly addressing the lock expiry described in the stem.

Why this answer

The LockDuration setting on a Service Bus queue controls how long a message is locked by a receiver before it becomes available for redelivery. Increasing this value prevents premature lock expiration during long processing, directly addressing the described issue.

Exam trap

AI-200 often tests whether candidates know that LockDuration is a queue-level property, not a client-side or function-level setting, and may confuse it with Event Hubs or Event Grid retry configurations.

How to eliminate wrong answers

Option B is wrong because Event Grid subscription retry intervals govern event delivery retries, not Service Bus message locks. Option C is wrong because Event Hubs consumer group retention period controls how long events are retained in the event stream, unrelated to message locking. Option D is wrong because the host.json eventHubs retry policy configures retry behavior for Event Hubs triggers in Azure Functions, not Service Bus lock duration.

Full explanation →

334

Multi-Selectmedium

You are deploying an AI model container in Azure Container Apps. Which TWO authentication mechanisms can you configure for securely pulling the image from a private Azure Container Registry?

Select 2 answers

A.ACR administrator username and password

B.Azure Active Directory client certificate stored in public DNS

C.Azure Storage account connection string

D.System-assigned managed identity

E.Anonymous public pull token

AnswersA, D

ACR administrator credentials authenticate registry pulls using the registry-level admin account, satisfying the private registry access requirement without needing Microsoft Entra integration. Container Apps accepts these as a registry credential when configuring the image source, though the shared account lacks per-identity scoping.

Why this answer

Option A (ACR administrator username and password) is correct because Azure Container Apps supports registry authentication using the registry's admin credentials, which are enabled on the ACR and supplied as username/password when configuring the registry in the container app. Option D (System-assigned managed identity) is correct because Container Apps can use a managed identity with the AcrPull role assignment on the registry, allowing image pulls without storing secrets. Option B is incorrect because a client certificate in public DNS is not a supported ACR authentication mechanism and public DNS is not a secure credential store.

Option C is incorrect because an Azure Storage account connection string authenticates to Blob/File storage, not to Azure Container Registry. Option E is incorrect because anonymous public pull tokens do not provide authenticated access to a private registry.

Exam trap

The trap here is that candidates see 'client certificate' or 'connection string' and assume any credential type works for ACR, but ACR authentication is specifically limited to Azure AD identities, admin credentials, or scoped tokens — not storage keys or certificates.

Full explanation →

335

Multi-Selectmedium

When configuring an Azure AI Search vector profile, which TWO elements must be successfully referenced together to make the profile functional? (Choose two)

Select 2 answers

A.A Cognitive Services storage blob container

B.An algorithm configuration name

C.A vectorizer name (if using integrated vectorization)

D.An Azure SQL connection string

E.A Cosmos DB throughput RU/s setting

AnswersB, C

A vector profile must bind a specific algorithm configuration by name, which defines the HNSW or exhaustive KNN parameters used to build and query the vector field. Without this reference, the profile cannot determine how vectors are indexed, so it fails to function.

Why this answer

Option B is correct because a vector profile in Azure AI Search must reference a valid algorithm configuration name (the HNSW or exhaustive KNN configuration defined in the index's vectorSearch.algorithms collection) that determines how vector similarity is computed during queries. Option C is correct because when integrated vectorization is used, the vector profile must also reference a vectorizer name (defined in the vectorSearch.vectorizers collection) so the search service can convert text queries into embeddings at query time. These two references — algorithm configuration and vectorizer — are the required components that make a vector profile functional.

Option A is incorrect because a Cognitive Services storage blob container is not part of a vector profile definition; blob containers are used as data sources for indexers, not for vector profiles. Option D is incorrect because an Azure SQL connection string belongs to a data source definition for indexers, not to a vector profile. Option E is incorrect because Cosmos DB RU/s throughput is a database provisioning setting and has no role in defining a vector profile.

Exam trap

AI-200 often tests whether candidates know that a vector profile is a composite object requiring both an algorithm configuration and (for integrated vectorization) a vectorizer — many pick unrelated data-source components like blob containers or SQL connections.

Full explanation →

336

MCQhard

You are configuring semantic ranking in Azure AI Search to improve search relevance for your enterprise application. Which tier of Azure AI Search is required to enable semantic ranking?

A.Storage Optimized (L1)

B.Standard (S1 or higher)

C.Free

D.Basic

AnswerB

Semantic ranking is unavailable on Free or Basic tiers; it requires Standard S1 or above. Selecting Standard satisfies the tier constraint in the stem, enabling the semantic reranker to reorder results and improve relevance for the enterprise application.

Why this answer

Semantic ranking in Azure AI Search requires the Standard tier (S1) or higher — it is not available on Free or Basic tiers. Semantic ranking uses Microsoft's language models to rerank the top results from BM25 or vector search, improving relevance for natural-language queries. Enabling it on a supported tier is done by adding a semantic configuration to the index and setting queryType to 'semantic'.

Exam trap

AI-200 often tests the assumption that Basic or Free tiers support semantic ranking; the trap is remembering that semantic ranking starts at Standard (S1) and is a separately metered feature.

How to eliminate wrong answers

Option A is wrong because Storage Optimized (L1) is designed for large indexes with lower query throughput and does not support semantic ranking — it is optimized for storage, not semantic reranking workloads. Option C is wrong because the Free tier does not support semantic ranking and has strict limits on index size, replicas, and features. Option D is wrong because the Basic tier, while supporting vector search, does not include semantic ranking — you must move to Standard (S1) or higher.

Full explanation →

337

Multi-Selectmedium

Your team is preparing an Azure AI application for production release. You need to implement robust monitoring and observability. Which TWO of the following steps should be taken? (Choose two)

Select 2 answers

A.Delete all log analytics workspaces weekly.

B.Rely solely on manual user bug reports without automated telemetry.

C.Configure Azure Monitor metric alerts and action groups for resource utilization and throttling thresholds.

D.Integrate the Application Insights SDK into application code to track requests, dependencies, and exceptions.

E.Disable all diagnostic logging to reduce storage overhead.

AnswersC, D

Azure Monitor metric alerts with action groups evaluate platform metrics such as CPU, memory and throttling, firing notifications when thresholds breach. This provides proactive detection of resource saturation and rate limiting, satisfying the production observability requirement for utilisation and throttling monitoring.

Why this answer

Option C is correct because Azure Monitor metric alerts with action groups provide automated, threshold-based notifications for resource utilization (such as CPU, memory, and request rates) and throttling (HTTP 429 responses), which are essential for detecting production issues proactively. Option D is correct because integrating the Application Insights SDK into the application code enables distributed tracing of requests, dependency calls, and exceptions, giving the end-to-end observability needed to diagnose failures and performance bottlenecks in an Azure AI application. Option A is incorrect because deleting Log Analytics workspaces weekly destroys the historical telemetry and query capability that monitoring depends on.

Option B is incorrect because relying solely on manual user bug reports provides no automated telemetry, leaving blind spots and delaying detection. Option E is incorrect because disabling diagnostic logging removes the audit and operational data needed for troubleshooting and compliance.

Exam trap

AI-200 often tests the misconception that monitoring can be achieved through manual reporting or that reducing logging overhead is beneficial, when in fact automated telemetry and alerts are essential for production observability.

Full explanation →

338

MCQhard

You are designing an enterprise-grade event-driven system where producers send financial transactions to Azure Event Hubs. You must guarantee that every single message is accounted for and that no data is lost even if an entire availability zone suffers a catastrophic failure. Which deployment configuration should you select for your Event Hubs namespace?

A.Configure Event Grid system topics with auto-delete set to false.

B.Deploy a Basic tier Event Hubs namespace with 30 consumer groups.

C.Use Azure Storage Queues configured with RA-GRS replication.

D.Deploy an Event Hubs namespace in a region supporting Availability Zones with zone redundancy enabled (Premium or Dedicated tier).

AnswerD

Zone redundancy replicates Event Hubs data across Availability Zones within the region, so message durability survives a full zone failure. Premium or Dedicated tier is required to enable this, satisfying the constraint that no transaction is lost during catastrophic zone outage.

Why this answer

Zone-redundant Event Hubs, available in Premium and Dedicated tiers, replicates data across three availability zones within a region. This ensures that if an entire availability zone fails, the namespace remains available and no committed messages are lost, satisfying the requirement for catastrophic AZ failure resilience.

Exam trap

AI-200 often tests the confusion between geo-replication (cross-region) and zone-redundancy (within-region), or assumes Basic tier supports high availability features when it does not.

How to eliminate wrong answers

Option A is wrong because Event Grid system topics are for event routing, not for storing financial transactions, and auto-delete settings do not provide zone redundancy or message durability. Option B is wrong because Basic tier Event Hubs does not support availability zones, has limited throughput units, and lacks the replication needed for AZ failure tolerance. Option C is wrong because Azure Storage Queues with RA-GRS provide geo-replication for storage, not event streaming, and RA-GRS replication is asynchronous with potential data loss, plus it does not meet the Event Hubs requirement.

Full explanation →

339

MCQmedium

You are implementing an event-driven architecture where an Azure Function acts as an Event Grid subscriber. Occasionally, the downstream cognitive service is throttled, causing failures. You need to ensure that unprocessable events are not lost and can be inspected later. Where should you configure a dead-letter destination?

A.On the Azure Function trigger binding definition using the deadLetterQueueName property.

B.On the Azure Storage account firewall settings as an IP filter exception.

C.On the Event Grid event subscription, specify an Azure Blob Storage container as the dead-letter endpoint.

D.Inside the Azure Function application configuration settings as an Application Insights error sink.

AnswerC

Event Grid dead-lettering stores undeliverable events when a subscriber fails, such as throttling. Setting an Azure Blob Storage container as the dead-letter endpoint on the event subscription preserves those events for later inspection instead of losing them.

Why this answer

Event Grid event subscriptions support a native dead-letter destination where events that cannot be delivered (after retries are exhausted) are stored as blobs in an Azure Storage container. This is configured on the event subscription itself, not on the subscriber, because Event Grid owns the delivery and retry lifecycle. The dead-lettered blob retains the original event payload plus failure metadata, enabling later inspection and reprocessing.

Exam trap

The trap here is confusing Service Bus dead-letter queues (a broker-side feature on queues/subscriptions) with Event Grid dead-letter destinations (a subscription-level blob storage setting) — candidates often pick the Function trigger binding because that is where they configure Service Bus dead-lettering.

How to eliminate wrong answers

Option A is wrong because deadLetterQueueName is a Service Bus / Storage Queue concept, not an Event Grid trigger binding property — Event Grid dead-lettering is configured on the subscription, not the Function trigger. Option B is wrong because storage firewall IP filters control network access, not event delivery failure handling. Option D is wrong because Application Insights is a telemetry and diagnostics sink; it can log exceptions but does not preserve the original undeliverable event payload for replay.

Full explanation →

340

MCQmedium

You are auditing your Azure AI services to ensure that all API keys are rotated regularly. What is the recommended practice for managing credentials in an enterprise AI solution?

A.Hardcode primary and secondary keys in application configuration files with failover logic.

B.Store API keys in plain text in Azure DevOps variable groups.

C.Rotate API keys manually every 7 days using the Azure portal.

D.Eliminate API keys by migrating authentication to Microsoft Entra ID managed identities.

AnswerD

Managed identities let Azure AI services authenticate to resources through Microsoft Entra ID token issuance, removing stored API keys entirely. This satisfies the stem's rotation requirement by eliminating the credential that would otherwise need periodic rotation, reducing leakage risk.

Why this answer

Microsoft Entra ID managed identities let an Azure resource authenticate to another Azure service (such as Azure AI Search, Azure OpenAI, or Key Vault) without any secret stored in code or configuration. The identity is created and its credentials are rotated automatically by the platform, which eliminates the entire key-rotation problem the question describes. This is Microsoft's recommended enterprise pattern for service-to-service authentication in AI solutions.

Exam trap

AI-200 often tests the misconception that 'rotate keys more often' is the best security answer, when the stronger and recommended answer is to eliminate keys altogether using managed identities.

How to eliminate wrong answers

Option A is wrong because hardcoding primary and secondary keys in configuration files exposes secrets in source control and deployment artifacts, and failover logic does not remove the need to rotate those keys. Option B is wrong because plain-text secrets in Azure DevOps variable groups are readable by anyone with pipeline access; secrets should be stored in Azure Key Vault and linked via variable groups or Key Vault-backed connections. Option C is wrong because manual 7-day rotation is operationally fragile, error-prone, and does not scale — it also leaves keys valid for up to a week if a leak occurs.

Full explanation →

341

Multi-Selectmedium

Which THREE logs or telemetry types should you collect in Azure Monitor to comprehensively troubleshoot an AI-powered web application?

Select 3 answers

A.Application requests and response status codes.

B.Dependency tracking for calls to Azure OpenAI and Azure AI Search.

C.Azure Bastion audit logs.

D.Trace logs emitted by the application code.

E.Azure Firewall packet capture PCAP files.

AnswersA, B, D

Request and response telemetry captures HTTP status codes, latency and failure rates at the application boundary, exposing which AI-backed endpoints are failing. This satisfies the stem's requirement to comprehensively troubleshoot the AI-powered web application by correlating front-end behaviour with back-end AI calls.

Why this answer

Application Insights collects request telemetry, dependency tracking for API calls, and trace logs for debugging logic.

Full explanation →

342

MCQmedium

Your application publishes messages to an Azure Service Bus queue. The messages contain sensitive personal data. Enterprise compliance mandates that message payloads are encrypted end-to-end at the application layer before being sent to Service Bus. How should you implement this?

A.Encrypt the message payload in your application code using a key from Azure Key Vault before sending, and decrypt upon receipt.

B.Configure Event Grid advanced filters to redact sensitive keys.

C.Enable Service Bus Premium Geo-Disaster Recovery with encryption enabled.

D.Use Shared Access Signature tokens with 5-minute expirations.

AnswerA

Service Bus encrypts data at rest and in transit, but not end-to-end at the application layer. Encrypting the payload in code with an Azure Key Vault key before sending, then decrypting on receipt, satisfies the compliance mandate for application-layer end-to-end encryption.

Why this answer

End-to-end application-layer encryption means the payload must be encrypted before it leaves the producer and decrypted only by the consumer, so the broker never sees plaintext. Using a key from Azure Key Vault to encrypt in code and decrypt on receipt satisfies this because Service Bus only transports ciphertext, and key custody stays in Key Vault.

Exam trap

AI-200 often tests whether candidates conflate platform-level encryption (at-rest CMK, TLS in transit, SAS authorization) with true application-layer end-to-end encryption, so options mentioning 'encryption enabled' or 'SAS tokens' look secure but do not meet the requirement.

How to eliminate wrong answers

Option B is wrong because Event Grid advanced filters evaluate event metadata for routing and cannot redact or encrypt message payloads. Option C is wrong because Geo-Disaster Recovery is a metadata replication feature for namespace failover and does not provide application-layer payload encryption. Option D is wrong because SAS tokens are an authorization mechanism for accessing the namespace; short expirations improve security posture but do not encrypt message contents.

Full explanation →

343

Multi-Selecteasy

You are managing costs for an Azure AI solution and want to prevent unexpected budget overruns. Which TWO of the following cost monitoring and governance tools can you use? (Choose two)

Select 2 answers

A.Azure Advisor cost recommendations

B.Azure Bastion subnet configuration

C.Azure Key Vault access policies

D.Azure Service Health incident dashboard

E.Azure Cost Management budgets and alerts

AnswersA, E

Azure Advisor analyses resource configuration and usage to surface cost recommendations, such as right-sizing or removing idle resources, letting you act before spend escalates. It provides the governance insight needed to prevent unexpected budget overruns in the AI solution.

Why this answer

Azure Advisor cost recommendations (A) is correct because it analyzes resource usage and configuration and surfaces actionable recommendations to reduce spend, such as rightsizing or shutting down idle resources, which directly helps prevent budget overruns. Azure Cost Management budgets and alerts (E) is correct because you can define a budget threshold and configure alerts that trigger when actual or forecasted costs approach or exceed that amount, enabling proactive governance. Azure Bastion subnet configuration (B) is incorrect because it concerns secure RDP/SSH connectivity to VMs, not cost monitoring or governance.

Azure Key Vault access policies (C) is incorrect because it governs secrets, keys, and certificate permissions, not spending. Azure Service Health incident dashboard (D) is incorrect because it reports platform outages and service issues, not cost or budget data.

Exam trap

AI-200 often tests whether candidates confuse general Azure governance services (Advisor, Cost Management) with unrelated services like Bastion, Key Vault, or Service Health, which sound administrative but have no cost-monitoring capability.

Full explanation →

344

MCQmedium

You are building a hybrid search solution using Azure AI Search that combines BM25 full-text search with vector search. What is the name of the feature that intelligently combines and normalizes scores from different retrieval systems before presenting the final top results?

A.Min-Max Score Scaling

B.Cosine Distance Normalization

C.Cross-Encoder Re-ranking

D.Reciprocal Rank Fusion (RRF)

AnswerD

RRF merges the BM25 and vector result sets by fusing each document's reciprocal rank rather than raw scores, so incomparable scoring scales never need normalising. This directly satisfies the stem's requirement to intelligently combine and normalise scores from different retrieval systems into one ranked result list.

Why this answer

Reciprocal Rank Fusion (RRF) is the algorithm Azure AI Search uses to merge BM25 and vector result sets in hybrid queries. It converts each result's rank into a reciprocal score (1/(k+rank)) and sums them, producing a normalized combined ranking without needing to align raw score scales. This is why hybrid search in Azure AI Search 'just works' without manual score normalization.

Exam trap

AI-200 often tests whether candidates know the specific named algorithm (RRF) rather than generic normalization terms — many pick 'Min-Max Score Scaling' because it sounds like what fusion does.

How to eliminate wrong answers

Option A is wrong because Min-Max Score Scaling is a generic normalization technique, not the named feature Azure AI Search uses for hybrid fusion. Option B is wrong because cosine distance normalization only applies to vector similarity scores and does not combine heterogeneous result sets. Option C is wrong because cross-encoder re-ranking is a separate semantic ranking stage that runs after fusion, not the fusion algorithm itself.

Full explanation →

345

MCQhard

You are running a containerized AI image classification service on Azure Kubernetes Service (AKS). The service must process images from an Azure Blob Storage account. You want the pods to access the storage without embedding credentials in the container image or Kubernetes secrets. Which authentication method should you use?

A.Configure the pod to use the AKS cluster's kubelet managed identity to access Blob Storage.

B.Enable Azure AD Pod Identity and assign a managed identity to the pod.

C.Use Azure Workload Identity to federate a Kubernetes service account with an Azure AD managed identity.

D.Store the storage account key in a Kubernetes Secret and mount it as an environment variable in the pod.

AnswerC

Azure Workload Identity is the recommended way to enable pods to access Azure resources without secrets. It federates a Kubernetes service account with an Azure AD managed identity, allowing the pod to obtain Azure AD tokens. This eliminates credential storage in images or secrets and provides fine-grained access control to Blob Storage.

Why this answer

Azure Workload Identity allows Kubernetes pods to authenticate to Azure services using a federated identity, avoiding secrets. It is the modern replacement for Azure AD Pod Identity and is the recommended method for credential-less access. Other options either use deprecated methods, store secrets, or misuse the kubelet identity, which does not provide the desired per-pod access control.

Exam trap

The trap here is confusing the kubelet managed identity, which operates at the node level for infrastructure tasks, with a pod-level identity for application access to Azure resources.

Full explanation →

346

MCQeasy

An AI system uses Azure Service Bus queues for processing text-generation jobs. A specific job causes the worker function to crash repeatedly, leading to the message being redelivered continuously. Which Service Bus feature should you configure to capture these poison messages after a specific delivery count is reached?

A.Duplicate detection

B.Dead-letter queue (DLQ)

C.Autoforwarding

D.Partitioning

AnswerB

The dead-letter queue moves messages aside once their delivery count exceeds the configured maximum, halting the crash-redelivery loop. This captures the poison message for later inspection, satisfying the requirement to isolate it after a specific delivery count.

Why this answer

The dead-letter queue (DLQ) captures messages that cannot be processed successfully after a specified number of delivery attempts. By configuring the queue's MaxDeliveryCount, you can automatically move poison messages to the DLQ after they exceed that count, preventing infinite redelivery loops. This allows you to inspect and handle problematic messages separately.

Exam trap

AI-200 often tests whether candidates confuse duplicate detection with dead-lettering, or assume that autoforwarding handles poison messages.

How to eliminate wrong answers

Option A is wrong because duplicate detection identifies and removes duplicate messages based on MessageId, not messages that fail processing. Option C is wrong because autoforwarding automatically forwards messages from one queue or subscription to another, which does not address poison messages. Option D is wrong because partitioning distributes messages across multiple partitions for scalability, not for handling failed deliveries.

Full explanation →

347

MCQmedium

Your team is building an automated image moderation pipeline. When an image is uploaded to Azure Blob Storage, you need to trigger an Azure Function to process it using Azure AI Vision. You want to ensure the lowest latency and native cloud event integration. Which integration approach should you configure?

A.Attach an Azure Event Hubs capture policy to the storage container.

B.Use an Azure Logic Apps polling trigger to check the storage container every minute for new files.

C.Configure an Azure Event Grid system topic and subscription for blob storage events targeting the Azure Function.

D.Write a background worker service that reads the Azure Service Bus queue populated by storage transactions.

AnswerC

An Event Grid system topic on the storage account pushes BlobCreated events to the Function through a native subscription, giving push-based, near-instant invocation rather than polling. This satisfies the lowest-latency and native cloud event integration constraints, unlike Blob Storage's legacy polling-based triggers or manual queue wiring.

Why this answer

Azure Event Grid natively integrates with Blob Storage via system topics and delivers blob-created events to subscribers such as Azure Functions with near-real-time push delivery. This is the lowest-latency, event-driven pattern and requires no polling or intermediate queue.

Exam trap

AI-200 often tests whether candidates default to polling or queue-based patterns when a native push-based event integration (Event Grid) is available, missing the latency and simplicity advantage.

How to eliminate wrong answers

Option A is wrong because Event Hubs capture is for streaming ingestion to storage, not for reacting to blob creation events. Option B is wrong because Logic Apps polling triggers introduce latency (up to the polling interval) and are not native event-driven integrations. Option D is wrong because Service Bus does not automatically receive blob storage events; you would need an intermediary publisher, adding complexity and latency.

Full explanation →

348

Multi-Selecthard

When designing a hybrid search architecture that integrates Azure AI Search with an Azure OpenAI embedding model, which THREE challenges must you typically address regarding data management and retrieval? (Choose three)

Select 3 answers

A.Ensuring model version consistency between ingestion embeddings and query embeddings

B.Managing re-indexing strategies when updating source documents or schema definitions

C.Provisioning HDInsight Hadoop clusters for vector distance calculations

D.Determining optimal text chunk size and overlap to balance context and precision

E.Configuring Azure SQL Server relational foreign key cascading deletes

AnswersA, B, D

Ingestion and query embeddings must come from the same model version, because vectors from different versions occupy incompatible spaces, degrading similarity. Pinning the deployment and re-embedding existing documents when the model changes prevents mismatched vector comparisons.

Why this answer

Option A is correct because vector search only returns meaningful results when the query embedding is generated by the same model and version that produced the document embeddings; mixing model versions or dimensions causes similarity scores to be invalid, so you must pin and track the embedding deployment/version across ingestion and query paths. Option B is correct because when source documents change or the index schema (fields, analyzers, vector profiles, dimensions) is modified, you must plan re-indexing or incremental refresh strategies to keep the index synchronized and avoid stale or orphaned vectors. Option D is correct because chunk size and overlap directly affect retrieval quality: chunks that are too large dilute the embedding's semantic focus, while chunks that are too small lose context, and overlap controls continuity across boundaries, so tuning these values is a core data-management decision.

Option C is not needed because vector distance calculations are performed natively by Azure AI Search's vector search capabilities, not by provisioning HDInsight Hadoop clusters. Option E is not relevant because Azure SQL Server foreign key cascading deletes concern relational data integrity and have no role in embedding generation, vector indexing, or hybrid retrieval in Azure AI Search.

Exam trap

AI-200 often tests whether candidates conflate search infrastructure with unrelated big-data or relational tools; the trap is picking HDInsight or SQL options that sound technical but have no role in vector retrieval.

Full explanation →

349

MCQmedium

Your enterprise security team mandates that all outbound traffic from your Azure Machine Learning workspace must pass through a centralized Azure Firewall, and no public IP addresses can be associated with workspace compute instances. Which workspace network isolation configuration should you select?

A.Public workspace with basic password authentication enabled on compute instances

B.Workspace using dynamic public IP allocation with Network Security Group (NSG) allow rules

C.Serverless compute instances with public endpoint access enabled

D.Workspace with a managed virtual network and outbound rules configured for user-defined routing through Azure Firewall

AnswerD

A managed virtual network isolates compute with no public IPs, and outbound rules let you force egress through your Azure Firewall via user-defined routes. This meets both constraints: centralised firewall inspection and no public IP addresses on compute instances.

Why this answer

To route all outbound traffic through a centralized Azure Firewall and prevent public IPs on compute instances, you must use a workspace with a managed virtual network and configure outbound rules for user-defined routing (UDR) through the firewall. This setup isolates compute in a private network and forces egress via the firewall.

Exam trap

AI-200 often tests the difference between public and private workspace configurations; candidates may choose NSG-based options thinking they provide isolation, but only managed VNet with UDR enforces no public IPs and centralized egress.

How to eliminate wrong answers

Option A is wrong because a public workspace with basic password authentication does not provide network isolation and allows public endpoints. Option B is wrong because dynamic public IP allocation with NSG rules still exposes compute instances to the internet and does not force traffic through Azure Firewall. Option C is wrong because serverless compute with public endpoint access enabled directly contradicts the requirement of no public IPs and centralized egress control.

Full explanation →

350

MCQmedium

You are deploying an AI model container to Azure Container Apps. The container application needs to securely connect to an Azure SQL Database without storing plain-text database credentials in environment variables or application code. What is the recommended feature to use?

A.Azure Key Vault references with managed identity

B.Azure Container Registry admin credentials

C.Container Apps encrypted environment variables

D.Kubernetes secrets mapped via sidecar proxy

AnswerA

Azure Key Vault references with managed identity let Container Apps retrieve secrets at runtime, so no plain-text credentials sit in environment variables or code. The managed identity authenticates to Key Vault without stored secrets, satisfying the stem's constraint of avoiding plain-text database credentials.

Why this answer

Azure Key Vault references combined with a managed identity let the container retrieve secrets at runtime without embedding credentials in code or environment variables. The managed identity authenticates to Key Vault, and the Key Vault reference resolves the secret into the app's configuration securely.

Exam trap

AI-200 often tests whether candidates confuse 'encrypted at rest' with 'not stored in the app definition' — encrypted environment variables still contain the secret, so Key Vault references with managed identity is the only option that removes the secret from the app entirely.

How to eliminate wrong answers

Option B is wrong because ACR admin credentials are for pulling images from the registry, not for authenticating to Azure SQL, and using them would still require storing a static secret. Option C is wrong because Container Apps encrypted environment variables still store the secret in the app configuration — encryption at rest does not remove the secret from the deployment definition or prevent exposure. Option D is wrong because Kubernetes secrets mapped via a sidecar proxy is a Kubernetes pattern, not the native Container Apps recommended approach, and it still requires storing the secret somewhere.

Full explanation →

351

Multi-Selectmedium

You are troubleshooting an Azure Function triggered by an Azure Event Grid subscription. The function is failing to receive events. Which TWO diagnostic steps should you take in the Azure Portal or via Azure CLI? Each correct answer is a valid troubleshooting action.

Select 2 answers

A.Inspect the configured dead-letter blob storage container for undelivered event files.

B.Verify the AMQP listener port 5671 firewall rules on the function app.

C.Check Event Grid metric charts for delivery failures, dropped events, and matched events.

D.Review Service Bus session lock renewal logs.

E.Check Event Hubs consumer group checkpoint offset status.

AnswersA, C

Inspecting the dead-letter container reveals events Event Grid could not deliver, confirming whether delivery failed after matching. This satisfies the diagnostic need to distinguish subscription or filtering faults from endpoint failures, since dead-lettered files only appear when delivery attempts to the function were exhausted.

Why this answer

Option A is correct because Event Grid supports a dead-letter destination (a Storage blob container) where events are written when they cannot be delivered to the subscriber, so inspecting that container reveals undelivered event files and their failure reasons. Option C is correct because Event Grid exposes metrics such as Delivery Failed Events, Dropped Events, and Matched Events in Azure Monitor, which directly show whether events are being matched to the subscription and whether delivery to the function is failing. Option B is not applicable because AMQP port 5671 is used by Service Bus and Event Hubs, not by Event Grid, which delivers events over HTTPS (port 443) to webhook/function endpoints.

Option D is not applicable because Service Bus session lock renewal is a Service Bus feature unrelated to Event Grid subscriptions. Option E is not applicable because Event Hubs consumer group checkpoints relate to Event Hubs consumption, not to Event Grid event delivery to an Azure Function.

Exam trap

AI-200 often tests whether candidates can identify the correct diagnostic surfaces for Event Grid delivery failures, luring them toward AMQP, Service Bus session, or Event Hubs checkpoint options that belong to other services.

Full explanation →

352

MCQeasy

Your team is developing an Azure Function that acts as an Event Grid webhook subscriber. You want to test the function locally using the Azure Functions Core Tools CLI. Which command starts the local runtime and enables local event ingestion?

A.func start

B.dotnet watch run-eventgrid

C.az eventgrid topic local-debug

D.az functionapp deployment source config

AnswerA

`func start` launches the local Functions host, which exposes the Event Grid webhook endpoint on localhost so events can be posted for ingestion. This satisfies the stem's requirement to run the runtime locally via Core Tools while enabling local event delivery, without deploying to Azure.

Why this answer

The Azure Functions Core Tools command `func start` launches the local Functions host, which exposes the HTTP trigger endpoint (typically http://localhost:7071/api/<function>) that Event Grid can target as a webhook subscriber. It also loads local.settings.json so you can point at a real Event Grid subscription for end-to-end local testing. This is the standard way to run and debug a function locally before deploying.

Exam trap

The trap is that candidates look for an Event Grid-specific local command, but the correct answer is the generic Functions host command `func start` — Event Grid has no local emulator in Core Tools.

How to eliminate wrong answers

Option B is wrong because `dotnet watch run-eventgrid` is not a valid .NET CLI command — `dotnet watch run` exists but has no Event Grid-specific verb, and it does not start the Functions host. Option C is wrong because `az eventgrid topic local-debug` is not a real Azure CLI command; `az eventgrid topic` supports create/list/show/delete, not a local-debug operation, and Azure CLI cannot run a local Event Grid emulator. Option D is wrong because `az functionapp deployment source config` configures continuous deployment source for a deployed Function App in Azure, not a local runtime.

Full explanation →

353

MCQmedium

Your application makes frequent calls to Azure AI Document Intelligence. You need to ensure that if a transient network failure or HTTP 503 service unavailable error occurs, the Python SDK automatically retries the failed requests with exponential backoff. How should you initialize the client to support robust retry behavior?

A.Write a custom infinite while loop wrapping every API call without sleep intervals

B.Disable all exception handling so the application crashes immediately on error

C.Configure Azure Traffic Manager with failover routing priorities

D.Instantiate the client with custom retry policy parameters (e.g., retry_total, retry_backoff_factor)

AnswerD

Passing retry_total and retry_backoff_factor configures the SDK's retry policy, enabling automatic retries with exponential backoff on transient failures and HTTP 503 responses. This satisfies the requirement for robust, automatic retry behaviour without custom wrapper code.

Why this answer

The Azure SDK for Python (azure-ai-documentintelligence / azure-ai-formrecognizer) exposes a retry policy through the client constructor, where you can pass retry_total, retry_backoff_factor, retry_on_status_codes, and related kwargs. Setting retry_backoff_factor enables exponential backoff automatically, and retry_total caps the number of attempts. This is the SDK-native, supported way to handle transient 503s and socket errors without hand-rolling logic.

Exam trap

AI-200 often tests whether candidates reach for infrastructure-level solutions (Traffic Manager, custom loops) when the correct answer is a client-side SDK configuration parameter that already implements exponential backoff.

How to eliminate wrong answers

Option A is wrong because an infinite while loop with no sleep creates a tight retry storm that hammers the service, ignores exponential backoff, and can trigger throttling or runaway costs. Option B is wrong because disabling exception handling causes immediate crashes on transient errors, which is the opposite of robust retry behavior. Option C is wrong because Azure Traffic Manager is DNS-level global routing for regional failover, not per-request retry logic inside a Python SDK client.

Full explanation →

354

MCQeasy

You are developing an AI application in Azure and need to monitor custom telemetry, trace dependencies, and track dependency failures for calls made to an external machine learning model endpoint. Which Azure service should you use?

A.Azure Advisor

B.Microsoft Defender for Cloud

C.Azure Policy

D.Application Insights

AnswerD

Application Insights provides distributed tracing, dependency tracking and custom telemetry through the Azure Monitor SDK, capturing outbound calls to the external model endpoint and their failures. This satisfies the requirement to trace dependencies and monitor custom telemetry.

Why this answer

Application Insights is Azure's application performance monitoring (APM) service, providing custom telemetry via the SDK, distributed tracing across dependencies, and failure tracking for outbound calls. It is the correct choice for monitoring an AI app's calls to an external ML endpoint, including latency, failure rates, and dependency maps.

Exam trap

AI-200 often tests whether candidates confuse monitoring/APM (Application Insights) with governance (Azure Policy) or security posture (Defender for Cloud), luring them toward services that do not collect runtime telemetry.

How to eliminate wrong answers

Option A is wrong because Azure Advisor gives best-practice recommendations on cost, security, reliability, and performance — it does not collect application telemetry or trace dependencies. Option B is wrong because Microsoft Defender for Cloud is a cloud security posture and workload protection service (CSPM/CWPP), not an APM tool. Option C is wrong because Azure Policy governs resource compliance and configuration, not runtime application telemetry.

Full explanation →

355

Multi-Selecthard

You are configuring secure ingress and network isolation for an Azure Container Apps environment. Which THREE capabilities are supported when configuring networking for Container Apps? (Choose three.)

Select 3 answers

A.Exposing the environment with either external (public) or internal (private VNet) ingress

B.Direct modification of physical Azure datacenter top-of-rack switches

C.Deploying the environment within a customer-managed Azure Virtual Network (VNet) subnet

D.Direct attachment of physical Fibre Channel storage SAN arrays

E.Configuring custom domain names with automated managed TLS/SSL certificates

AnswersA, C, E

Container Apps environments support both external ingress, which publishes apps on a public endpoint, and internal ingress, which restricts traffic to a private Azure Virtual Network. This directly satisfies the stem's requirement for secure ingress and network isolation, letting you choose public exposure or VNet-only access per environment.

Why this answer

Option A is correct because Azure Container Apps environments support both external ingress, which exposes apps to the public internet via a public endpoint, and internal ingress, which restricts access to a private VNet or the environment's internal network. Option C is correct because you can deploy a Container Apps environment into a customer-managed Azure Virtual Network subnet, enabling network isolation, private endpoints, and control over inbound/outbound traffic. Option E is correct because Container Apps supports custom domain names with automated managed TLS/SSL certificates, including free managed certificates for custom domains and binding of existing certificates.

Option B is incorrect because customers cannot directly modify physical Azure datacenter top-of-rack switches; Azure manages the physical network infrastructure. Option D is incorrect because attaching physical Fibre Channel SAN arrays is not a supported Container Apps networking capability; persistent storage in Container Apps is provided through Azure Files or managed storage abstractions, not direct SAN attachment.

Exam trap

AI-200 often tests whether candidates confuse Container Apps networking with IaaS-level controls — the trap is picking physical switch or SAN options, which are never customer-accessible in a PaaS service.

Full explanation →

356

Multi-Selecthard

You are designing a high-performance RAG data layer architecture using Azure AI Search. Which THREE indexing and retrieval strategies should you implement to maximize recall and precision? (Choose three)

Select 3 answers

A.Enable semantic ranker to re-order top results using deep learning models

B.Disable all scoring and ranking algorithms to save CPU cycles

C.Tune HNSW parameters (m, efConstruction, efSearch) for optimal recall vs latency balance

D.Store embeddings as plain text strings in unindexed fields

E.Implement hybrid search combining BM25 keyword matching with vector similarity

AnswersA, C, E

The semantic ranker re-orders the top hybrid results using deep learning language models, promoting passages that genuinely answer the query. This directly raises precision at the top of the result list without changing the underlying recall.

Why this answer

Option A is correct because Azure AI Search's semantic ranker applies deep-learning language models (Microsoft's semantic re-ranking) to re-order the top BM25/vector results, improving precision by promoting semantically relevant documents that lexical or vector scoring alone may rank lower. Option C is correct because HNSW (Hierarchical Navigable Small World) is the approximate nearest neighbor algorithm used in Azure AI Search vector indexes, and tuning m (number of bi-directional links per node), efConstruction (index-time candidate list size), and efSearch (query-time candidate list size) directly controls the recall-versus-latency tradeoff — higher values increase recall at the cost of latency. Option E is correct because hybrid search fuses BM25 keyword scoring with vector similarity (via Reciprocal Rank Fusion in Azure AI Search), capturing both exact term matches and semantic similarity, which raises recall and precision versus either method alone.

Option B is incorrect because disabling scoring and ranking would eliminate relevance ordering entirely, destroying precision rather than maximizing it. Option D is incorrect because embeddings must be stored in vector fields (Collection(Edm.Single) with a vector profile and HNSW configuration) to be searchable; storing them as plain text in unindexed fields makes them unusable for vector retrieval.

Exam trap

AI-200 often tests whether candidates understand that recall and precision require a combination of indexing (HNSW tuning), retrieval (hybrid search), and re-ranking (semantic ranker), rather than a single silver bullet.

Full explanation →

357

MCQeasy

An event subscriber endpoint hosted on an Azure App Service web app is failing to receive events from an Azure Event Grid system topic. Upon investigation, you discover Event Grid received a handshake validation failure. What is the most likely cause?

A.The event payload exceeded the 1 megabyte size limit.

B.The Service Bus connection string was incorrectly formatted.

C.The web app did not correctly handle and echo back the validation code during the Webhook handshake.

D.The App Service pricing tier does not support HTTPS connections.

AnswerC

Event Grid validates a webhook subscription by sending a SubscriptionValidationEvent containing a validation code; the endpoint must echo that code back in the response. If the App Service returns anything else, validation fails and the subscription is rejected, so events never flow.

Why this answer

Event Grid requires a webhook validation handshake when a new event subscription is created. The subscriber endpoint must respond to the validation event by echoing back the validation code within a short timeout. If the web app fails to handle this handshake—for example, by not returning the validation code or returning an error—Event Grid marks the subscription as failed and does not deliver events.

The most likely cause is that the web app did not correctly process and echo the validation code.

Exam trap

AI-200 often tests the misconception that event delivery failures are due to payload size or authentication, when the root cause is often the initial webhook validation handshake not being handled correctly.

How to eliminate wrong answers

Option A is wrong because the 1 MB event size limit applies to event payloads, not to the handshake validation, and a size violation would produce a different error. Option B is wrong because Service Bus connection strings are unrelated to Event Grid system topic subscriptions; Event Grid uses webhooks or other event handlers. Option D is wrong because Azure App Service supports HTTPS on all pricing tiers, including the free tier, so HTTPS support is not the issue.

Full explanation →

358

MCQhard

You are optimizing storage costs and search latency for a massive Azure AI Search vector index containing 50 million records, each with 3,072-dimensional embeddings from text-embedding-3-large. Which Azure AI Search feature should you implement to reduce memory footprint while maintaining acceptable recall?

A.Exhaustive K-nearest neighbor (exact KNN) search

B.Scoring profiles with magnitude boosting

C.Scalar Quantization (SQ)

D.Semantic enrichment with Azure AI Language

AnswerC

Scalar Quantization compresses each vector component from 32-bit floats to 8-bit integers, cutting index memory roughly fourfold across 50 million records. This directly reduces the memory footprint constraint while retaining acceptable recall, unlike binary quantization which sacrifices far more accuracy.

Why this answer

Scalar Quantization (SQ) compresses each float32 vector component into a smaller integer (typically 8-bit), reducing the in-memory and on-disk footprint of the vector index by roughly 4x while preserving enough precision to maintain acceptable recall. For a 50-million-record index with 3,072-dimension embeddings, this is the Azure AI Search feature explicitly designed to trade a small amount of recall for substantial memory and cost savings.

Exam trap

AI-200 often tests whether candidates confuse memory-reduction techniques (SQ, BQ, PQ) with ranking or enrichment features, tempting them to pick 'exhaustive KNN' as if it were an optimization.

How to eliminate wrong answers

Option A is wrong because exhaustive KNN performs a brute-force comparison against every vector, which increases latency and memory pressure rather than reducing footprint — it is the opposite of what is needed at 50M scale. Option B is wrong because scoring profiles with magnitude boosting affect how text relevance scores are weighted in ranking; they have no effect on vector index memory. Option D is wrong because semantic enrichment with Azure AI Language adds NLP-derived metadata (entities, key phrases) to documents and does not compress or shrink the vector index.

Full explanation →

359

MCQhard

Your team has noticed a significant cost spike in your Azure OpenAI usage. You need to identify which specific deployment is responsible for the highest token consumption. Which tool provides the most granular visibility into this data?

A.Azure Monitor metrics with splitting on the 'DeploymentName' dimension.

B.Azure Advisor cost recommendations.

C.Application Insights logs via KQL query on the 'requests' table.

D.Azure Cost Management analysis on the resource group.

AnswerA

Azure Monitor metrics expose token usage split by the 'DeploymentName' dimension, isolating consumption per deployment. This granularity identifies which specific deployment drives the cost spike, unlike aggregated billing views that cannot attribute spend to individual deployments.

Why this answer

Azure Monitor platform metrics for Azure OpenAI expose a 'DeploymentName' dimension on metrics such as TokenTransaction, ProcessedPromptTokens, and GeneratedCompletionTokens. Splitting on that dimension gives per-deployment token consumption, which is the most granular native view for attributing cost to a specific deployment.

Exam trap

The trap here is assuming Application Insights or Cost Management gives per-deployment token detail, when only Azure Monitor platform metrics with the DeploymentName dimension natively provide that granularity.

How to eliminate wrong answers

Option B is wrong because Azure Advisor provides high-level cost recommendations and does not break down token usage per deployment. Option C is wrong because Application Insights 'requests' table captures request telemetry only if the app is instrumented and does not natively expose token counts per deployment without custom logging. Option D is wrong because Azure Cost Management aggregates spend at the resource or resource-group level and cannot attribute cost to an individual model deployment.

Full explanation →

360

MCQmedium

You want to track the latency of your model inference API in production. Which Azure tool should you integrate into your containerized application?

A.Azure Application Insights.

B.Azure Storage Queue.

C.Azure Event Hubs.

D.Azure Data Factory.

AnswerA

Application Insights provides request-level telemetry, dependency tracking and latency metrics for containerised workloads via its SDK or auto-instrumentation. It captures inference API response times and distributions, satisfying the stem's constraint of tracking production model inference latency in a containerised application.

Why this answer

Azure Application Insights is the Application Performance Management (APM) service within Azure Monitor, designed to capture request latency, dependency calls, exceptions, and custom telemetry from applications. Integrating the Application Insights SDK (or OpenTelemetry) into the containerized inference API automatically records request duration and end-to-end transaction traces. This directly answers the requirement to track inference API latency in production.

Exam trap

AI-200 often tests the distinction between telemetry/APM services (Application Insights) and data transport services (Event Hubs, Storage Queues), causing candidates to pick a messaging service for a monitoring requirement.

How to eliminate wrong answers

Option B is wrong because Azure Storage Queue is a messaging service for asynchronous decoupling, not a telemetry or latency-monitoring tool. Option C is wrong because Azure Event Hubs is a big-data streaming ingestion platform, not an APM solution — it can transport telemetry but does not measure or visualize latency. Option D is wrong because Azure Data Factory is an ETL/orchestration service for data pipelines and has no application performance monitoring capability.

Full explanation →

361

MCQhard

You are designing a multi-tenant AI ingestion pipeline using Azure Event Hubs. You need to ensure that low-priority tenants cannot starve high-priority tenants of partition resources. Which feature should you implement?

A.Set the Capture interval to 60 seconds for low-priority partitions.

B.Deploy separate Event Hubs namespaces for high-priority and low-priority tenants.

C.Configure RBAC permissions to restrict low-priority tenants to Reader roles.

D.Enable Azure DDoS Protection Standard on the Event Hubs consumer group.

AnswerB

Separate Event Hubs namespaces give each tenant tier independent throughput units and partition capacity, so low-priority tenants cannot consume the partitions high-priority tenants depend on. This isolation directly satisfies the requirement to prevent resource starvation across priority tiers.

Why this answer

Event Hubs throughput and partition resources are scoped to a namespace, so tenants sharing a single namespace compete for the same throughput units and partitions. Deploying separate namespaces for high-priority and low-priority tenants physically isolates their throughput units, partitions, and throttling limits, preventing noisy-neighbor starvation. This is the standard multi-tenant isolation pattern for Event Hubs.

Exam trap

The trap is assuming that RBAC or Capture settings can enforce performance fairness; candidates must recognize that Event Hubs isolation for throughput requires namespace-level separation, not permission or capture tuning.

How to eliminate wrong answers

Option A is wrong because the Capture interval only controls how often captured data is written to Blob Storage or Data Lake; it has no effect on partition allocation or consumer throughput, so it cannot prevent starvation. Option C is wrong because RBAC Reader roles only restrict control-plane and data-plane permissions; they do not reserve or prioritize partition throughput, and a Reader can still consume at full speed if granted the data receiver role. Option D is wrong because Azure DDoS Protection Standard protects against volumetric network attacks on public IPs and has nothing to do with Event Hubs consumer groups or partition fairness.

Full explanation →

362

Multi-Selectmedium

When configuring an Azure AI Search vector index, which TWO parameters can be adjusted within the HNSW algorithm configuration to trade off between search speed, memory usage, and recall accuracy? (Choose two)

Select 2 answers

A.efSearch

B.replicaCount

C.partitionCount

D.maxTextLength

E.m

AnswersA, E

efSearch controls how many candidate neighbours the HNSW search explores at query time. Raising it improves recall accuracy at the cost of slower searches, while lowering it speeds queries and reduces recall, directly providing the speed, memory and accuracy trade-off the stem requires.

Why this answer

Option A, efSearch, is correct because it sets the size of the dynamic candidate list used during query time in HNSW; increasing efSearch explores more neighbors, improving recall accuracy at the cost of slower searches, while decreasing it speeds up queries with lower recall. Option E, m, is correct because it defines the number of bidirectional links created for each node in the HNSW graph; a higher m improves recall and accuracy but consumes more memory, whereas a lower m reduces memory usage and speeds up indexing/search with reduced recall. Option B, replicaCount, is incorrect because it controls the number of replicas for high availability and query throughput in Azure AI Search, not the HNSW speed/memory/recall tradeoff.

Option C, partitionCount, is incorrect because it controls index partitioning for storage and write scaling, not HNSW tuning. Option D, maxTextLength, is incorrect because it is a field/analyzer-related setting for text content length, unrelated to HNSW graph parameters.

Exam trap

AI-200 often tests confusion between service-scaling parameters (replicas, partitions) and algorithm-level HNSW parameters (m, efSearch, efConstruction), so candidates must recognize which layer each knob operates at.

Full explanation →

363

MCQhard

You are troubleshooting high latency in an AI inference workload on AKS. You suspect the issue is caused by container startup time (cold starts). Which feature helps mitigate this?

A.Configuring Vertical Pod Autoscaler.

B.Azure Container Registry Artifact Streaming.

C.Increasing the memory limit for the pod.

D.Using a smaller base OS distribution.

AnswerB

Artifact streaming pulls only the container layers needed to start, rather than downloading the full image first. This directly cuts image-pull time, the dominant contributor to cold-start latency for AKS inference pods, satisfying the stem's container startup constraint.

Why this answer

Azure Container Registry (ACR) Artifact Streaming (also called streaming artifacts) allows container image layers to be pulled on demand as the container starts, rather than downloading the entire image first. This dramatically reduces cold-start time for large AI inference images by letting the container begin execution while layers stream in the background. It directly addresses the container startup latency described.

Exam trap

AI-200 often tests whether candidates conflate resource scaling (VPA, memory limits) with image delivery optimization, causing them to pick autoscaling or resource-tuning answers when the root cause is image pull latency.

How to eliminate wrong answers

Option A is wrong because Vertical Pod Autoscaler adjusts CPU/memory requests and limits based on usage — it does not affect image pull or container startup time. Option C is wrong because increasing the memory limit addresses OOM issues or memory pressure, not cold-start latency from image download. Option D is wrong because using a smaller base OS distribution reduces image size and can help, but it is a build-time optimization, not a runtime feature that mitigates cold starts for existing large images; ACR Artifact Streaming is the targeted feature.

Full explanation →

364

MCQeasy

Which property in an Azure Cosmos DB for NoSQL SQL query specifies the maximum number of vector search results to return?

A.TOP

B.FETCH FIRST

C.LIMIT

D.MAXROWS

AnswerA

TOP sets the maximum number of results returned by a Cosmos DB for NoSQL query, directly satisfying the vector search result limit. Applied as `SELECT TOP N`, it caps rows after the ORDER BY VectorDistance ranking, so the nearest N vectors are returned without retrieving the full candidate set.

Why this answer

In the Azure Cosmos DB for NoSQL SQL query syntax, TOP is the keyword that limits the number of results returned, and it is used with vector search queries to cap the number of nearest-neighbor results. For example, 'SELECT TOP 10 c.id FROM c ORDER BY VectorDistance(c.embedding, @queryVector)' returns the 10 closest matches. This mirrors T-SQL semantics rather than PostgreSQL or MySQL syntax.

Exam trap

AI-200 often tests cross-database SQL syntax confusion; the trap is picking LIMIT or FETCH FIRST because they are familiar from PostgreSQL or MySQL, when Cosmos DB for NoSQL exclusively uses TOP.

How to eliminate wrong answers

Option B is wrong because FETCH FIRST is ANSI SQL / PostgreSQL / Oracle syntax and is not supported in Cosmos DB for NoSQL. Option C is wrong because LIMIT is MySQL/PostgreSQL syntax and Cosmos DB for NoSQL does not recognize it. Option D is wrong because MAXROWS is not a Cosmos DB SQL keyword at all — it is not part of the NoSQL query grammar.

Full explanation →

365

MCQmedium

You are building a RAG application using Azure AI Search. You want to ensure that the search results provided to the LLM are as relevant as possible by leveraging a re-ranking model. Which service must be enabled to utilize the 'Semantic Ranker'?

A.Standard Tier or higher

B.Basic Tier

C.Free Tier

D.Storage Optimized Tier

AnswerA

Semantic Ranker requires Azure AI Search at Standard tier or above; Free and Basic tiers do not expose semantic ranking. Enabling it satisfies the stem's relevance constraint by applying Microsoft's language models to re-rank the initial BM25 or vector result set, promoting semantically closest chunks before they reach the LLM.

Why this answer

Semantic Ranker in Azure AI Search requires the Standard tier or higher; it is not available on the Free or Basic tiers. Enabling Semantic Ranker allows the service to re-rank search results using a deep learning model, improving relevance for RAG applications by promoting semantically relevant documents.

Exam trap

AI-200 often tests the minimum tier required for Semantic Ranker — candidates may incorrectly assume Basic or Free tiers support it, but Standard is the minimum.

How to eliminate wrong answers

Option B is wrong because the Basic tier does not support Semantic Ranker; it only offers basic indexing and querying capabilities. Option C is wrong because the Free tier lacks Semantic Ranker and has strict limits on storage and indexes. Option D is wrong because 'Storage Optimized' is a tier optimized for large indexes with lower query throughput, but it is not the minimum tier for Semantic Ranker; Standard is the entry point.

Full explanation →

366

MCQhard

You are designing a RAG solution where documents are dynamically updated in Azure AI Search. You notice that search results return outdated information immediately after document updates. What is the cause of this behavior?

A.Semantic ranker caches search results for exactly 30 days

B.Azure OpenAI embedding models require a 24-hour cool-down period before new embeddings become valid

C.Vector indexes in Azure AI Search are read-only after creation and cannot accept updates

D.The indexer has not yet run its scheduled synchronization cycle to process changes from the data source

AnswerD

Indexers pull changes on a schedule rather than continuously, so freshly updated source documents remain absent from the index until the next synchronisation cycle completes. The stale results are expected latency, not a query or scoring fault.

Why this answer

In Azure AI Search, data source changes are not automatically reflected in the index; an indexer must run to pull, transform, and load updated content. If the indexer is on a schedule (e.g., every 5 minutes or hourly), there is an inherent delay between the source update and the index refresh. Until that synchronization cycle completes, queries hit the old index data, returning outdated results.

This is expected behavior, not a bug, and can be mitigated by triggering the indexer on-demand or using a change detection policy.

Exam trap

AI-200 often tests the misconception that Azure AI Search automatically syncs with data sources in real-time, leading candidates to overlook the need for indexer scheduling or triggering.

How to eliminate wrong answers

Option A is wrong because the semantic ranker does not cache results at all—it re-ranks the top results from the initial query using semantic models, and there is no 30-day cache. Option B is wrong because Azure OpenAI embedding models do not have a 24-hour cool-down; embeddings are generated immediately upon request, and new embeddings become valid as soon as they are indexed. Option C is wrong because vector indexes in Azure AI Search are fully updatable; you can add, update, or delete documents and their vectors at any time, provided the index schema supports it.

Full explanation →

367

MCQeasy

An application publishes custom events to an Azure Event Grid custom topic. You need to route events dynamically based on the event's 'department' property in the event payload. Which filtering mechanism should you configure on the Event Grid subscription?

A.Event Hubs Capture filters

B.Advanced Filters

C.Subject Begins With/Ends With filters

D.Service Bus Correlation Filters

AnswerB

Advanced Filters evaluate payload properties using operators such as StringIn, NumberGreaterThan and BoolEquals, so the subscription matches on the 'department' value inside the event data. Subject-prefix filtering only inspects the event subject string, which cannot express this payload-based routing condition.

Why this answer

Advanced Filters in Azure Event Grid allow filtering based on any property within the event payload, including custom properties like 'department'. They support operators such as string comparisons, numeric comparisons, and boolean logic, enabling dynamic routing based on event data. This is the correct mechanism because the requirement is to filter on a custom property in the event schema, which Advanced Filters are designed to handle.

Exam trap

AI-200 often tests the confusion between Event Grid filtering mechanisms and similar features in other Azure messaging services, leading candidates to select Service Bus Correlation Filters or Subject filters when the requirement involves custom event properties.

How to eliminate wrong answers

Option A is wrong because Event Hubs Capture filters are not a feature of Event Grid; Event Hubs Capture is a separate service for archiving streaming data to storage, and it does not provide filtering capabilities for Event Grid subscriptions. Option C is wrong because Subject Begins With/Ends With filters only operate on the event's subject field, not on custom properties within the event payload, so they cannot filter based on the 'department' property. Option D is wrong because Service Bus Correlation Filters are used in Azure Service Bus subscriptions to filter messages based on correlation properties, not in Event Grid, and they do not apply to Event Grid event payloads.

Full explanation →

368

MCQmedium

You are building a container image for an AI model that requires GPU acceleration. You plan to run it on Azure Kubernetes Service (AKS). Which step must you take to ensure the pods can access GPU resources?

A.Use a GPU-enabled node pool and set the container's runtime to nvidia in the Dockerfile.

B.Configure the pod to use the hostPath volume /dev/nvidia* to access the GPU devices directly.

C.Install the NVIDIA device plugin for Kubernetes and specify GPU resource limits in the pod specification.

D.Enable GPU support in the AKS cluster by setting the --enable-gpu flag during cluster creation.

AnswerC

To use GPUs in AKS, you must deploy the NVIDIA device plugin, which advertises GPU resources to the Kubernetes scheduler. Then, in the pod spec, you request nvidia.com/gpu resources. This allows the pod to be scheduled on a GPU node and access the GPU. Without the plugin, Kubernetes cannot allocate GPUs to pods.

Why this answer

To use GPUs in AKS, you must install the NVIDIA device plugin, which exposes GPU resources to Kubernetes. Then, in the pod spec, you request nvidia.com/gpu resources to schedule on GPU nodes. Other options either reference non-existent flags, rely on Dockerfile settings, or use unsafe hostPath mounts that bypass scheduling.

Exam trap

The trap here is thinking that a Dockerfile runtime directive or a cluster creation flag enables GPU access, when in fact the NVIDIA device plugin and resource requests are required.

Full explanation →

369

MCQeasy

You want to find out which Azure subscriptions and resource groups are incurring the highest costs for Azure Machine Learning compute instances this month. Where should you view this cost breakdown?

A.Azure Advisor security dashboard

B.Application Insights availability tests

C.Azure Monitor Metric alerts

D.Cost Analysis grouped by Resource Group and filtered by Service Name 'Machine Learning'

AnswerD

Cost Analysis supports grouping by Resource Group and filtering by Service Name, so filtering 'Machine Learning' isolates compute instance spend and grouping reveals the highest-cost subscriptions and resource groups, satisfying the stem's breakdown requirement precisely.

Why this answer

Cost Analysis in Azure Cost Management allows you to group and filter costs by subscription, resource group, and resource type.

Full explanation →

370

MCQhard

An AI application hosted in Azure App Service throws intermittent socket exhaustion errors under heavy load when calling Azure OpenAI. You suspect improper HTTP client management. How should you fix this in .NET?

A.Configure a private endpoint between the App Service and Azure OpenAI.

B.Use IHttpClientFactory to manage client lifecycles instead of instantiating new HttpClient objects per request.

C.Enable Always On in the App Service configuration settings.

D.Increase the TCP keep-alive timeout on the Azure App Service instance configuration.

AnswerB

IHttpClientFactory pools and recycles underlying HttpMessageHandler instances, so sockets are reused rather than exhausted. Creating a new HttpClient per request leaves handlers undisposed, exhausting ephemeral ports under load. The factory directly resolves the intermittent socket exhaustion constraint.

Why this answer

In .NET, creating a new HttpClient per request leads to socket exhaustion because each instance holds its own connection pool and disposed clients leave sockets in TIME_WAIT. IHttpClientFactory pools and reuses HttpMessageHandler instances, resolving the exhaustion while still allowing per-request client configuration.

Exam trap

AI-200 often tests whether candidates recognize socket exhaustion as an HttpClient lifecycle issue rather than a networking or App Service configuration issue, luring them toward private endpoints or Always On.

How to eliminate wrong answers

Option A is wrong because a private endpoint addresses network isolation and does not fix socket lifecycle management. Option C is wrong because Always On keeps the App Service warm but does not affect HttpClient socket reuse. Option D is wrong because increasing TCP keep-alive does not address the root cause of creating and disposing HttpClient instances per request.

Full explanation →

371

MCQhard

Your Azure OpenAI model deployment is experiencing a sudden latency spike. You want to determine if the bottleneck is due to server-side processing time or network transport overhead in your client application. Which Application Insights telemetry property should you inspect?

A.Dependency telemetry duration compared against custom client-side timers wrapping the API call

B.Azure Storage replication lag metrics

C.Azure Advisor performance score

D.Azure Policy compliance evaluation duration

AnswerA

Comparing dependency telemetry duration with custom client-side timers isolates server-side processing from network transport: the dependency duration captures the outbound call as measured by the SDK, while your own timer wraps the full round trip. Any gap between them quantifies transport and client overhead, directly satisfying the stem's requirement to separate the two latency sources.

Why this answer

Application Insights dependency telemetry records the duration of outbound calls (including Azure OpenAI) as measured server-side by the SDK, so comparing that duration against a custom client-side timer that wraps the same API call isolates network/transport overhead from server processing time. If the client timer is much larger than the dependency duration, the delta is transport or client-side latency.

Exam trap

AI-200 often tests whether candidates can distinguish server-side telemetry (dependency duration) from end-to-end client measurement — picking a governance or cost tool instead of Application Insights dependency data is the common wrong path.

How to eliminate wrong answers

Option B is wrong because Azure Storage replication lag is unrelated to Azure OpenAI inference latency and would not appear in Application Insights dependency data for the model call. Option C is wrong because Azure Advisor performance scores are periodic best-practice recommendations, not per-request latency telemetry. Option D is wrong because Azure Policy compliance evaluation duration measures governance scan time, not API call latency.

Full explanation →

372

Multi-Selecthard

You are troubleshooting a containerized AI model deployment in Azure Container Apps that fails to pass its HTTP readiness probe. You need to inspect the container logs and runtime diagnostics. Which THREE tools or commands can you use to troubleshoot this issue? Each correct answer presents a complete solution.

Select 3 answers

A.Access the Azure Portal and use the Console diagnostic tool for the specific container app revision.

B.Run the az containerapp logs show Azure CLI command.

C.Query the Log Analytics workspace configured for the Container Apps environment.

D.Execute az aks browse to open the Kubernetes dashboard.

E.Use kubectl describe pod to inspect Kubernetes events.

AnswersA, B, C

The Console diagnostic tool opens an interactive shell in the running container app revision, letting you inspect processes, environment and probe endpoints directly. This provides runtime diagnostics for the failing HTTP readiness probe without redeploying the container.

Why this answer

Option A is correct because the Azure Portal's Console diagnostic tool for a specific container app revision opens an interactive shell inside the running container, letting you inspect the filesystem, processes, and probe-related runtime behavior directly. Option B is correct because 'az containerapp logs show' retrieves the system and console log streams for a container app (with parameters like --name, --resource-group, and --revision), which is exactly what you need to see why the HTTP readiness probe is failing. Option C is correct because Container Apps environments can send console and system logs to a Log Analytics workspace, where you can query them with KQL (for example, the ContainerAppConsoleLogs_CL and ContainerAppSystemLogs_CL tables) to diagnose probe failures.

Option D is not correct because 'az aks browse' targets Azure Kubernetes Service clusters, not Azure Container Apps, and it opens a Kubernetes dashboard rather than exposing container logs. Option E is not correct because 'kubectl describe pod' works against a Kubernetes API server and pods, whereas Container Apps is a serverless platform that abstracts away pods and does not expose them to kubectl.

Exam trap

AI-200 often tests whether candidates confuse Azure Container Apps with AKS, so any answer mentioning kubectl, the Kubernetes dashboard, or pod-level commands is a distractor because Container Apps hides the Kubernetes layer.

Full explanation →

373

Multi-Selectmedium

Your enterprise application uses Azure Event Grid. Which TWO event schemas are natively supported when publishing events to an Event Grid custom topic? (Choose two)

Select 2 answers

A.Apache Kafka record batch binary schema

B.AMQP 1.0 binary stream envelope

C.SOAP 1.2 XML messaging schema

D.CloudEvents 1.0 schema

E.Azure Event Grid schema

AnswersD, E

CloudEvents 1.0 is a natively supported schema for Event Grid custom topics, satisfying the stem's requirement for supported publish formats. Event Grid accepts both the proprietary Event Grid schema and CloudEvents 1.0, so publishers can emit interoperable, CNCF-standard events without transformation. This makes CloudEvents 1.0 one of the two valid choices.

Why this answer

Azure Event Grid custom topics natively support two event schemas for publishing: the CloudEvents 1.0 schema (option D) and the proprietary Azure Event Grid schema (option E). CloudEvents 1.0 is the CNCF-standardized, interoperable envelope format that Event Grid accepts directly, while the Azure Event Grid schema is the service's original native format with fields like 'eventType', 'subject', 'data', and 'dataVersion'. Both are selectable via the topic's input schema setting and are the only two schemas Event Grid accepts for custom topic publishing.

Options A, B, and C are incorrect: Apache Kafka record batch binary, AMQP 1.0 binary stream envelopes, and SOAP 1.2 XML are not supported input schemas for Event Grid custom topics, even though Event Grid can deliver to Kafka or use AMQP internally for its own transport.

Exam trap

The trap is confusing Event Grid schemas with Event Hubs or Service Bus protocols (Kafka, AMQP, SOAP); candidates must remember that Event Grid supports exactly two schemas: Event Grid schema and CloudEvents 1.0.

Full explanation →

374

MCQmedium

You are writing a query in Azure Cosmos DB for NoSQL to retrieve documents based on vector similarity against a target embedding. Which built-in SQL function should you use in the ORDER BY clause?

A.CosSimilarity()

B.EmbeddingDistance()

C.GetVectorDistance()

D.VectorDistance()

AnswerD

VectorDistance() computes cosine, dot product or Euclidean distance between stored vectors and the query embedding, so ordering by it returns the nearest neighbours first. It is the only built-in NoSQL function that satisfies the vector similarity ranking constraint in the ORDER BY clause.

Why this answer

Azure Cosmos DB for NoSQL exposes the VectorDistance() built-in function, which computes the similarity/distance between a stored vector property and a query vector, and is used inside ORDER BY to rank results by similarity. It supports cosine, dot product, and Euclidean metrics via an optional third argument. This is the documented function for vector search queries in the NoSQL API.

Exam trap

AI-200 often tests whether candidates recognize the exact built-in function name, since distractors like CosSimilarity() and GetVectorDistance() sound plausible but are not part of the Cosmos DB SQL API.

How to eliminate wrong answers

Option A is wrong because CosSimilarity() is not a Cosmos DB NoSQL function — it resembles naming from other vector databases and is a distractor. Option B is wrong because EmbeddingDistance() does not exist in the Cosmos DB SQL grammar. Option C is wrong because GetVectorDistance() is also not a valid Cosmos DB function; it mimics generic naming but is not part of the API surface.

Full explanation →

375

MCQmedium

You need to deploy a set of batch AI processing containers in Azure Container Instances that run to completion and then terminate. Which container group restart policy should you select?

A.Always

B.Never

C.UnlessStopped

D.OnFailure

AnswerB

The Never restart policy ensures containers in the group run once to completion and are not restarted, matching the batch requirement that they terminate after finishing. Always would loop them indefinitely, and OnFailure would restart only failed containers, neither suiting run-to-completion jobs.

Why this answer

For Azure Container Instances running batch workloads that execute to completion and then terminate, the restart policy must be Never. This tells ACI not to restart the container after it exits, allowing the container group to reach a terminal Succeeded state. It is the correct choice for run-once batch AI processing jobs.

Exam trap

AI-200 often tests restart policy semantics, so the trap is choosing OnFailure thinking it means 'run once and stop,' when it actually restarts on any non-zero exit, or choosing Always for a batch job.

How to eliminate wrong answers

Option A is wrong because Always restarts the container continuously, which is appropriate for long-running services, not batch jobs that should terminate. Option C is wrong because UnlessStopped is not a valid ACI restart policy value — ACI supports Always, OnFailure, and Never only. Option D is wrong because OnFailure restarts the container only if it exits with a non-zero code, which is useful for retry-on-error but not for a job that should terminate after completion regardless of exit code.

Full explanation →

Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) (AI-200) — Questions 301–375