Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) AI-200 Questions 226–300 | Page 4/6

226

MCQhard

You are reviewing security logs in Azure Key Vault and notice unexpected access attempts from an unrecognized IP address. You need to immediately revoke all active Azure Active Directory tokens issued to a specific compromised user or service principal across your Azure AI applications. What action should you take?

A.Restart the Azure portal browser session

B.Revoke user refresh tokens using Azure AD PowerShell (Revoke-AzureADUserAllRefreshToken) or Microsoft Entra admin center

C.Change the Azure subscription display name

D.Delete the Azure Monitor Log Analytics workspace

AnswerB

Correct. Revoking refresh tokens invalidates all active sessions and tokens immediately across all connected applications.

Why this answer

Revoking refresh tokens invalidates the user's or service principal's ability to silently obtain new access tokens, effectively terminating the session across all clients. The Revoke-AzureADUserAllRefreshToken cmdlet (or the equivalent 'Revoke sessions' action in the Microsoft Entra admin center) sets the refreshTokensValidFromDateTime to now, so any token issued before that timestamp is rejected. This is the correct immediate containment step for a compromised identity.

Exam trap

AI-200 often tests the misconception that restarting a client session or deleting logs remediates a compromised identity, when the actual containment action is revoking refresh tokens at the Entra ID layer.

How to eliminate wrong answers

Option A is wrong because restarting a browser session only clears local cookies on one device — it does not invalidate tokens already issued to other clients or the attacker's session. Option C is wrong because changing the subscription display name is a cosmetic metadata change with no security effect on authentication tokens. Option D is wrong because deleting a Log Analytics workspace destroys telemetry and evidence, and does nothing to revoke tokens or stop the attacker.

Full explanation →

227

MCQeasy

You need to inspect the environment variables and configuration settings of a running container group in Azure Container Instances. Which Azure CLI command should you use?

A.az container exec --exec-command env

B.az aks inspect

C.az container list-secrets

D.az container show --resource-group myRG --name myContainer

AnswerD

az container show retrieves the full JSON properties of a container group, including environment variables and configuration settings, directly satisfying the inspection requirement. It queries the running group's current state rather than logs or metrics, which would not expose configuration values.

Why this answer

The az container show command retrieves the full JSON representation of a container group, including its container definitions, environment variables, image, ports, resource requests, and current provisioning state. This is the correct way to inspect configuration of a running container group without executing into it.

Exam trap

AI-200 often tests the confusion between inspecting configuration (az container show) and executing commands inside a container (az container exec), especially when the word 'environment variables' appears in both contexts.

How to eliminate wrong answers

Option A is wrong because az container exec runs a command inside the container — while 'env' would print environment variables at runtime, the question asks to inspect configuration settings of the container group, and exec requires the container to be running and is not the configuration-inspection command. Option B is wrong because az aks inspect is not a valid Azure CLI command (AKS diagnostics use az aks show, az aks get-credentials, or kubectl). Option C is wrong because az container list-secrets is not a valid command — secrets in ACI are surfaced via az container show output, not a dedicated list-secrets verb.

Full explanation →

228

Multi-Selectmedium

When configuring vector search in Azure Cosmos DB for NoSQL, which TWO properties must be defined within the container's vector embedding policy? Choose two.

Select 2 answers

A.Container partition key definition

B.BM25 k1 and b tuning parameters

C.Replication lag threshold

D.Path (the JSON property containing the vector array)

E.DataType (e.g., float32) and Dimensions (e.g., 1536)

AnswersD, E

The vector embedding policy requires a `path` entry naming the JSON property that holds the vector array, so Cosmos DB knows which field to index for similarity queries. Without it, the container cannot locate embeddings, and vector search fails. This satisfies the stem's requirement that the property containing the vector array be declared.

Why this answer

Option D is correct because the vector embedding policy must specify the "path" — the JSON property path in each document that holds the vector array — so Cosmos DB knows which field to index for vector search. Option E is correct because the policy must also declare the vector's "dataType" (e.g., float32, float16, int8) and "dimensions" (e.g., 1536), which define the element type and length of the vector array and must match the actual embeddings. The container partition key definition (A) is set in the container's key definition, not the vector embedding policy, and is unrelated to vector indexing.

BM25 k1 and b parameters (B) belong to full-text search scoring configuration, not vector search. Replication lag threshold (C) is a consistency/global replication setting and has no place in a vector embedding policy.

Exam trap

AI-200 often tests the misconception that partition key or search tuning parameters belong in the vector embedding policy, when only path, dataType, and dimensions are required.

Full explanation →

229

Multi-Selecthard

You are designing an enterprise search architecture that combines Azure AI Search and Azure OpenAI. Which THREE strategies help optimize hybrid search relevance and retrieval quality? Choose three.

Select 3 answers

A.Tune HNSW parameters (m and efSearch) based on recall and latency trade-offs

B.Implement Reciprocal Rank Fusion (RRF) to combine lexical and vector ranks

C.Enable Azure AI Search semantic ranker for deep learning re-ranking

D.Disable all OData filters to maximize vector recall

E.Store all embeddings as uncompressed plaintext strings in Blob Storage

AnswersA, B, C

Tuning HNSW parameters directly controls the recall-versus-latency balance in vector queries, satisfying the stem's retrieval-quality constraint. Raising m improves graph connectivity and recall; efSearch trades query latency for accuracy. This makes it a valid hybrid relevance optimisation strategy alongside semantic ranking and scoring profile adjustments.

Why this answer

Option A is correct because HNSW parameters directly control the approximate nearest neighbor graph: increasing m improves recall at the cost of memory and index build time, while efSearch tunes the query-time candidate list to balance recall against latency, making it a core lever for hybrid search relevance. Option B is correct because Reciprocal Rank Fusion (RRF) merges the ranked result lists from keyword (BM25) and vector queries into a single ranking using 1/(k + rank) scoring, which is exactly how Azure AI Search combines lexical and vector results in hybrid mode. Option C is correct because the semantic ranker applies deep-learning re-ranking (Microsoft's cross-encoder models) over the top results, promoting semantically relevant documents that lexical or vector scores alone may rank lower.

Option D is not correct because disabling OData filters does not improve vector recall and removes useful precision controls; filters are applied alongside vector search to narrow the candidate set. Option E is not correct because storing embeddings as uncompressed plaintext in Blob Storage is inefficient and unrelated to search relevance; embeddings should be stored in the search index as Collection(Edm.Single) vectors, ideally with compression such as scalar or binary quantization.

Exam trap

AI-200 often tests the misconception that more data or disabling filters improves recall, when in fact relevance tuning comes from HNSW parameter tuning, RRF fusion, and semantic re-ranking — not from removing constraints or changing storage format.

Full explanation →

230

MCQhard

You are configuring secure image signing and verification for your AI containers using Azure Container Registry and Notation. Which feature enables cryptographically signed container images?

A.ACR Signature Verification / Microsoft Defender artifact signing with Notation

B.Azure Key Vault managed HSM key rotation

C.ACR Georeplication sync tokens

D.Docker Content Trust (Notary v1)

AnswerA

ACR Signature Verification integrates Notation with Microsoft Entra ID–backed certificates, storing signatures as OCI artifacts alongside the image. This satisfies the stem's requirement for cryptographic signing and verification, since Notation uses COSE signatures validated against trusted certificate chains before deployment.

Why this answer

ACR Signature Verification, integrated with Microsoft Defender for Containers and Notation (the CNCF Notary v2 project), enables cryptographically signed container images and policy-based verification at pull time. Notation uses the OCI 1.1 referrers API to store signatures as artifacts alongside the image, and ACR can enforce that only signed images are pulled. This is the modern, standards-based approach for supply-chain integrity in Azure.

Exam trap

AI-200 often tests the shift from Docker Content Trust (Notary v1) to Notation (Notary v2) for ACR image signing, so candidates who pick the legacy DCT option get it wrong.

How to eliminate wrong answers

Option B is wrong because Key Vault managed HSM key rotation manages cryptographic keys but does not sign or verify container images. Option C is wrong because ACR georeplication sync tokens control replication across regions, not image signing. Option D is wrong because Docker Content Trust (Notary v1) is the legacy signing mechanism, deprecated in favor of Notation/Notary v2, and not the feature Microsoft positions for ACR signature verification.

Full explanation →

231

Multi-Selectmedium

Your enterprise application architecture incorporates Azure Cosmos DB for NoSQL as the primary operational data store and Azure AI Search as the vector index for semantic search. Which THREE mechanisms can you use to keep the Azure AI Search vector index synchronized with changes in Azure Cosmos DB?

Select 3 answers

A.Configure an Azure AI Search indexer connected to an Azure Cosmos DB change feed data source.

B.Use Azure Event Grid to capture container mutation events and orchestrate indexing updates.

C.Deploy an Azure Function triggered by the Azure Cosmos DB change feed to push document inserts and updates directly to the Azure AI Search REST API.

D.Execute a full database table scan and drop-rebuild of the search index every 5 minutes using Azure Data Factory batch pipelines.

E.Enable native real-time bidirectional memory-mapped replication between Azure Cosmos DB database partitions and search service replicas.

AnswersA, B, C

An Azure AI Search indexer with an Azure Cosmos DB data source reads the container's change feed, incrementally detecting inserts and updates and pushing them into the index. This provides native, scheduled pull-based synchronisation without custom orchestration code.

Why this answer

Option A is correct because Azure AI Search natively supports an Azure Cosmos DB data source for indexers, which reads the container's change feed (including inserts, updates, and deletes when soft-delete/change-feed policies are configured) and incrementally pushes documents into the vector index. Option B is correct because Azure Cosmos DB emits container mutation events to Azure Event Grid, which can trigger downstream orchestration (for example, Functions, Logic Apps, or custom handlers) that updates Azure AI Search documents via its REST/SDK APIs. Option C is correct because the Azure Cosmos DB change feed can be consumed by an Azure Function trigger, and the function can call the Azure AI Search REST API (for example, the index or merge-or-upload actions) to upsert vectors and fields in near real time.

Option D is not appropriate because a full scan plus drop-and-rebuild every 5 minutes is a costly, high-latency batch pattern rather than an incremental synchronization mechanism, and Azure Data Factory is not the recommended vector-index sync path. Option E is not a real capability: Azure Cosmos DB does not provide native bidirectional memory-mapped replication to Azure AI Search replicas; synchronization must be implemented through indexers, change feed consumers, or event-driven pipelines.

Exam trap

AI-200 often tests whether candidates invent non-existent 'native replication' features between Azure services; the trap is choosing a plausible-sounding but fictional option like memory-mapped bidirectional sync instead of the three documented integration patterns.

Full explanation →

232

Multi-Selecthard

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

Select 3 answers

A.Private endpoints using Azure Private Link

B.Event Grid MQTT broker certificate authentication

C.IP firewall rules

D.Virtual Network (VNet) service endpoints

E.Blob storage container access policies

AnswersA, C, D

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

Why this answer

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

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

Exam trap

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

Full explanation →

233

MCQeasy

You are deploying a containerized AI web API to Azure Container Apps. The API must be accessible from the public internet over HTTPS. You have already created the container app and deployed the image. Which of the following should you configure to enable external ingress with automatic HTTPS?

A.Set the ingress to 'external' and enable 'allowInsecure' to false in the container app configuration.

B.Deploy the container app to an internal environment and configure a private DNS zone for public resolution.

C.Enable HTTP/2 and set the transport to 'auto' in the ingress settings.

D.Create an Azure Application Gateway with a public IP and configure it to forward traffic to the container app's internal endpoint.

AnswerA

In Azure Container Apps, to expose a container app to the public internet, you configure ingress with 'external' set to true (or 'external' in CLI). By default, Container Apps provides automatic HTTPS with a fully managed certificate. Setting 'allowInsecure' to false ensures that only HTTPS traffic is allowed, redirecting HTTP to HTTPS. This meets the requirement for secure public access.

Why this answer

Azure Container Apps provides built-in ingress that can be configured as external to expose the app to the internet. When external ingress is enabled, Container Apps automatically provisions a fully managed TLS certificate and supports HTTPS. Setting 'allowInsecure' to false enforces HTTPS-only traffic.

Other options either add unnecessary components or do not provide public access.

Exam trap

The trap here is overcomplicating the solution by introducing additional services like Application Gateway, when Container Apps natively supports external ingress with automatic HTTPS.

Full explanation →

234

MCQmedium

You are managing multiple containerized AI models in AKS. You want to implement a service mesh to handle traffic splitting and mTLS. Which tool should you integrate?

A.Calico.

B.Azure Application Gateway Ingress Controller (AGIC).

C.Istio.

D.Azure Load Balancer.

AnswerC

Istio provides native traffic splitting through VirtualService weights and mutual TLS between pods, meeting both requirements without custom code. Its sidecar proxies enforce mTLS automatically, whereas alternatives such as Linkerd or ingress-only controllers lack the same combined traffic-shifting and mTLS feature set.

Why this answer

Istio is a full-featured service mesh that provides traffic splitting (via VirtualService and DestinationRule), mutual TLS (mTLS) between workloads, observability, and policy enforcement. It is the standard choice for AKS service mesh requirements, and AKS offers an Istio add-on for simplified installation and lifecycle management. This directly satisfies the traffic-splitting and mTLS requirements.

Exam trap

The trap is confusing ingress controllers (AGIC) or CNIs (Calico) with service meshes; only Istio provides the combination of traffic splitting and mTLS that the question requires.

How to eliminate wrong answers

Option A is wrong because Calico is a CNI and network policy engine, not a service mesh — it does not provide traffic splitting or mTLS. Option B is wrong because AGIC is an ingress controller that routes external HTTP(S) traffic into the cluster; it does not provide east-west mTLS or fine-grained traffic splitting between services. Option D is wrong because Azure Load Balancer is an L4 load balancer that distributes TCP/UDP traffic but has no concept of service mesh, mTLS, or HTTP-level traffic splitting.

Full explanation →

235

MCQmedium

Your containerized AI application needs to access sensitive API keys. What is the most secure way to provide these to your application in Azure Container Apps?

A.Store them in environment variables in the YAML file.

B.Hardcode them in the application code.

C.Store them in a sidecar container.

D.Use Azure Key Vault references.

AnswerD

Key Vault references let Container Apps resolve secrets at runtime through the app's managed identity, so API keys never enter the container image, environment variables, or revision configuration. This satisfies the sensitive-credential requirement by removing plaintext secrets from the deployment entirely.

Why this answer

Azure Key Vault references let Container Apps pull secrets at runtime from Key Vault using the app's managed identity, so the secret value never appears in the YAML, image, or environment in plaintext. This centralizes secret management, enables rotation without redeploying, and provides audit trails. It is the recommended pattern for sensitive API keys in Container Apps.

Exam trap

AI-200 often tests that 'environment variables in YAML' and 'hardcoded in code' are insecure, so candidates must recognize Key Vault references with managed identity as the only secure option among the choices.

How to eliminate wrong answers

Option A is wrong because environment variables in the YAML are stored in plaintext in the revision template and visible to anyone with read access to the resource — not secure for API keys. Option B is wrong because hardcoding secrets in code embeds them in the image and source control, the worst possible practice. Option C is wrong because a sidecar container is just another process in the same pod; it does not provide secure secret storage or access control by itself.

Full explanation →

236

MCQmedium

You are running an AI inference workload in an Azure Kubernetes Service (AKS) cluster. The pods require access to an Azure Machine Learning workspace data store via managed identity without storing credentials in code. Which Kubernetes feature should you configure?

A.Azure CNI Overlay

B.Kubernetes Secrets CSI driver

C.Node-level Managed Identity

D.Azure AD Workload Identity

AnswerD

Workload Identity federates a Kubernetes service account with a Microsoft Entra ID identity via OIDC, letting pods obtain tokens for the Azure Machine Learning data store without embedded credentials. This satisfies the no-stored-credentials constraint, unlike pod-managed identity or secrets.

Why this answer

Azure AD Workload Identity federates a Kubernetes service account with an Azure AD application (or user-assigned managed identity) using OIDC, allowing pods to obtain Azure AD tokens without storing secrets. This is the supported, recommended way for AKS pods to access Azure resources like an AML workspace data store using managed identity.

Exam trap

AI-200 often tests the distinction between node-level managed identity (shared by all pods, discouraged) and Azure AD Workload Identity (per-pod, OIDC-federated), luring candidates toward the simpler but insecure node-level option.

How to eliminate wrong answers

Option A is wrong because Azure CNI Overlay is a networking plugin that changes pod IP addressing (pods get IPs from an overlay CIDR rather than the VNet), unrelated to identity or credential management. Option B is wrong because the Secrets Store CSI driver mounts secrets from Key Vault as volumes — it still relies on an identity to authenticate to Key Vault and is not the mechanism that provides the managed identity itself. Option C is wrong because node-level managed identity assigns an identity to the VMSS nodes, meaning every pod on the node shares that identity — it violates least privilege and is explicitly discouraged for multi-tenant or per-workload access.

Full explanation →

237

MCQeasy

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

A.Azure Service Bus Topics

B.Azure Storage Queues

C.Azure Event Hubs

D.Azure Event Grid

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

238

MCQeasy

You need to prevent accidental deletion of a production Azure OpenAI resource that contains critical customer deployment configurations. Which Azure resource lock configuration should you apply?

A.CanNotDelete resource lock

B.ReadOnly resource lock

C.Azure Policy deny assignment

D.Network Security Group deny rule

AnswerA

A CanNotDelete lock permits read and modify operations but blocks deletion, so administrators can still update deployment configurations while accidental removal of the production Azure OpenAI resource is prevented. ReadOnly would be excessive, since it would also block legitimate configuration changes.

Why this answer

The correct resource lock is CanNotDelete. This lock prevents accidental deletion of the Azure OpenAI resource while still allowing read and modify operations. It ensures that the resource cannot be deleted until the lock is removed, providing a safety net against unintended deletion.

Exam trap

AI-200 often tests the distinction between CanNotDelete and ReadOnly locks, with candidates incorrectly choosing ReadOnly when modification is still needed.

How to eliminate wrong answers

Option B is wrong because a ReadOnly lock prevents any modifications, including updates to deployment configurations, which may be necessary for operations; it is too restrictive for a production resource that might need changes. Option C is wrong because Azure Policy deny assignment is used to enforce organizational standards and can deny certain actions, but it is not a resource lock and does not specifically prevent deletion of a single resource; it is applied at a scope and can be complex. Option D is wrong because a Network Security Group deny rule controls network traffic, not resource management operations; it cannot prevent deletion of a resource.

Full explanation →

239

Multi-Selecthard

You are optimizing an enterprise search architecture using Azure AI Search. Which THREE mechanisms help control latency and resource consumption during heavy vector query loads? (Choose three)

Select 3 answers

A.Tuning HNSW efSearch parameter to balance recall speed and latency

B.Disabling caching and increasing index document count per partition beyond limits

C.Applying scalar quantization to compress vectors and reduce memory overhead

D.Running exhaustive k-NN searches for every query by default

E.Scaling out search replicas to distribute query traffic across nodes

AnswersA, C, E

Raising or lowering efSearch adjusts how many candidate neighbours HNSW explores per query. A lower value cuts latency at some recall cost; a higher value improves recall. This tunable trade-off directly controls query latency under heavy vector load.

Why this answer

Option A is correct because the HNSW efSearch parameter controls the size of the dynamic candidate list during vector search; lowering efSearch reduces the number of distance computations, cutting latency at some cost to recall, which is exactly the recall/latency trade-off needed under heavy vector query loads. Option C is correct because scalar quantization compresses float32 vectors into smaller representations (e.g., int8), reducing memory footprint and memory bandwidth pressure so more vectors fit in RAM and queries execute faster. Option E is correct because adding search replicas horizontally distributes query traffic across multiple nodes, increasing concurrent query throughput and preventing any single node from becoming a latency bottleneck.

Option B is incorrect because disabling caching removes a latency-reducing mechanism and pushing documents per partition beyond limits is unsupported and degrades performance. Option D is incorrect because exhaustive k-NN scans every vector for each query, which dramatically increases compute and latency and is unsuitable as a default under heavy load.

Exam trap

The trap is treating exhaustive k-NN as a performance optimization — it's actually the slowest option, and candidates who confuse 'exact' with 'efficient' pick it incorrectly.

Full explanation →

240

Multi-Selecthard

You are designing the data storage and indexing strategy for a multi-tenant AI search solution on Azure. Which TWO architectural practices should you implement to optimize vector search performance and tenant isolation in Azure AI Search?

Select 2 answers

A.Disable the HNSW algorithm and rely exclusively on exhaustive brute-force search across all tenant partitions.

B.Store all tenants' embeddings in a single unpartitioned vector field without metadata tags to maximize index density.

C.Implement security trimming by appending OData filter expressions (e.g., tenantId eq 'tenant-1') to every vector search query.

D.Store raw embeddings exclusively in Azure Blob Storage and perform client-side cosine similarity calculations for all queries.

E.Provision dedicated Azure AI Search indexes or service tiers for enterprise tenants requiring strict isolation and predictable vector search latency.

AnswersC, E

OData filter expressions appended to each vector query restrict results to the caller's tenant at query time, so one shared index can serve many tenants without cross-tenant leakage. This satisfies the stem's tenant isolation requirement while avoiding per-tenant index proliferation.

Why this answer

Option C is correct because Azure AI Search supports security trimming via OData filter expressions such as tenantId eq 'tenant-1' applied to vector queries, which enforces tenant isolation by restricting results to documents matching the caller's tenant identifier while still allowing shared indexes. Option E is correct because provisioning dedicated indexes or service tiers for enterprise tenants provides physical/logical isolation and dedicated compute, ensuring predictable vector search latency and strict data separation for high-compliance customers. Option A is wrong because disabling HNSW and relying on exhaustive brute-force (exhaustive KNN) search sacrifices scalability and latency, and brute-force across all tenant partitions does not provide tenant isolation.

Option B is wrong because storing all tenants' embeddings in a single unpartitioned vector field without metadata tags prevents filtering and security trimming, breaking tenant isolation. Option D is wrong because moving embeddings to Blob Storage and computing cosine similarity client-side eliminates Azure AI Search's optimized vector indexing and integrated filtering, harming performance and isolation.

Exam trap

AI-200 often tests whether candidates understand that vector search isolation requires both a filterable tenant metadata field and, for strict isolation, dedicated indexes — candidates mistakenly believe a single unpartitioned vector field is sufficient.

Full explanation →

241

MCQeasy

Which Azure service provides cloud-scale vector search backed by either HNSW or DiskANN algorithms alongside managed NoSQL capabilities?

A.Azure Logic Apps

B.Azure Cosmos DB for NoSQL

C.Azure Functions

D.Azure Virtual Machines

AnswerB

Azure Cosmos DB for NoSQL natively embeds vector indexing, letting you choose HNSW for in-memory speed or DiskANN for large, disk-resident datasets, while retaining its managed NoSQL document store. This single-engine combination satisfies both the cloud-scale vector search and managed NoSQL requirements the stem demands.

Why this answer

Azure Cosmos DB for NoSQL natively supports vector search with HNSW and DiskANN algorithms integrated into its managed, globally distributed NoSQL database. It combines the vector index with the document store, so embeddings and metadata live in the same container and are queried with SQL-like syntax.

Exam trap

The trap is assuming vector search requires a dedicated service like Azure AI Search — candidates miss that Cosmos DB for NoSQL has first-class native vector support with HNSW and DiskANN built in.

How to eliminate wrong answers

Option A is wrong because Azure Logic Apps is a workflow orchestration service with no native vector indexing or similarity search capability. Option C is wrong because Azure Functions is a serverless compute platform for running code, not a database — it can call a vector store but does not provide one. Option D is wrong because Azure Virtual Machines are raw IaaS compute; you could self-host a vector database on a VM, but that is not a managed cloud-scale vector search service.

Full explanation →

242

Multi-Selectmedium

You are configuring vector search options in Azure Cosmos DB for NoSQL. Which TWO distance metrics are supported when defining a vector embedding policy? (Choose two)

Select 2 answers

A.hamming

B.manhattan

C.jaccard

D.euclidean

E.cosine

AnswersD, E

Euclidean measures straight-line L2 distance between vectors and is one of the two metrics Azure Cosmos DB for NoSQL accepts in a vector embedding policy, alongside cosine. Specifying it in the policy satisfies the requirement to define a supported distance function.

Why this answer

In Azure Cosmos DB for NoSQL, the vector embedding policy's "distanceFunction" property accepts exactly three values: cosine, dotproduct, and euclidean. Option D (euclidean) is correct because Euclidean distance is one of the natively supported metrics, measuring straight-line distance between vectors and typically used with normalized or unnormalized embeddings. Option E (cosine) is correct because cosine similarity is the default and most commonly used metric, measuring the angle between vectors and ideal for text embeddings where magnitude is irrelevant.

Option A (hamming) is not supported; it applies to binary/categorical string comparison, not the float32 vector indexes Cosmos DB builds. Option B (manhattan) is not supported; only cosine, dotproduct, and euclidean are valid distanceFunction values. Option C (jaccard) is not supported; it is a set-similarity measure used in data mining, not a Cosmos DB vector distance metric.

Exam trap

AI-200 often tests whether candidates know the exact set of supported distance functions in Cosmos DB — the trap is selecting plausible-sounding metrics like Manhattan or Jaccard that are used elsewhere but not supported here.

Full explanation →

243

MCQmedium

You are implementing vector search in Azure AI Search for a document retrieval system. You need to ensure that the vector search returns the most relevant results for a query embedding. Which similarity metric should you configure in the vector search profile?

A.Euclidean distance

B.Cosine similarity

C.Dot product

D.Jaccard similarity

AnswerB

Cosine similarity measures the cosine of the angle between vectors, focusing on orientation rather than magnitude. It is widely used for text embeddings because it effectively captures semantic similarity regardless of vector length. Azure AI Search supports cosine as a similarity metric, and it is the recommended choice for most embedding models, ensuring relevant results in retrieval scenarios.

Why this answer

Cosine similarity is the most suitable metric for text embeddings because it normalizes for vector magnitude and focuses on semantic orientation. Azure AI Search supports cosine as a vector similarity metric, and it aligns with common embedding models, ensuring that the most semantically similar documents are retrieved based on the query embedding.

Exam trap

The trap here is assuming that any distance metric works equally well, when the choice must match the embedding model's training objective.

Full explanation →

244

MCQmedium

You are optimizing an AI model container image size. Which technique is most effective for reducing the footprint of an image based on a large Python deep learning framework?

A.Implement multi-stage Docker builds.

B.Enable ACR Georeplication.

C.Store model weights as image layers.

D.Use the 'latest' tag for all base images.

AnswerA

Multi-stage builds let you compile and install dependencies in a builder stage, then copy only the runtime artefacts into a slim final image, discarding build tooling, caches and source layers that otherwise bloat a framework-based Python image.

Why this answer

Multi-stage Docker builds let you compile/install dependencies in a builder stage and copy only the runtime artifacts into a slim final stage, discarding build tools, caches, and intermediate files. For a large Python deep learning framework (e.g., PyTorch/TensorFlow), this can cut image size dramatically because compilers, pip caches, and dev headers never reach the final image. It is the standard technique for shrinking ML container images without losing functionality.

Exam trap

AI-200 often tests the misconception that registry-level features (georeplication, tagging) reduce image size, when only build-time techniques like multi-stage builds actually change the image footprint.

How to eliminate wrong answers

Option B is wrong because ACR Georeplication replicates a registry across regions for latency/availability; it does not change the size of any image. Option C is wrong because storing model weights as image layers adds to the image size rather than reducing it, and weights are better mounted from external storage or downloaded at runtime. Option D is wrong because using the 'latest' tag is an anti-pattern that harms reproducibility and does not reduce image footprint at all.

Full explanation →

245

Multi-Selecteasy

You are designing an operational dashboard in Azure Monitor. Which TWO visualization components can you include in an Azure Workbook? (Choose two)

Select 2 answers

A.Azure SQL database table creation scripts (DDL)

B.KQL query result grids and charts

C.Azure Key Vault plain-text master password files

D.Docker container image binary layers

E.Azure Monitor metric charts

AnswersB, E

Workbooks render KQL query results as grids and charts, letting operators visualise Log Analytics and Azure Monitor metrics interactively. This satisfies the stem's requirement for visualisation components, since both are native Workbook tiles rather than separate dashboard-only features.

Why this answer

Option B is correct because Azure Workbooks natively render KQL query results as grids, charts, and other visualizations, which is the core mechanism for displaying Log Analytics data in a workbook. Option E is correct because Workbooks can also visualize Azure Monitor platform metrics directly through metric chart components, letting you combine metrics and logs in one dashboard. Options A, C, and D are incorrect because DDL scripts, Key Vault plain-text secrets, and Docker image binary layers are not visualization components and cannot be embedded as workbook tiles; Workbooks only display query/metric-based visualizations, text, links, and parameters.

Full explanation →

246

MCQmedium

You are troubleshooting an AI inference container in Azure Container Apps that fails to start because it cannot pull the base image from Azure Container Registry. Authentication fails with an unauthorized error. What is the recommended way to grant the Container App access to ACR?

A.Hardcode the admin username and password into environment variables

B.Configure a system-assigned managed identity on the Container App and assign the AcrPull role on ACR

C.Expose the ACR endpoint publicly without authentication

D.Attach an Azure Storage Account SAS token to the container environment

AnswerB

A system-assigned managed identity gives the Container App an Microsoft Entra ID identity, and assigning the AcrPull role on the registry authorises image pulls without storing credentials. This eliminates the unauthorised error while avoiding secrets in configuration, which is the recommended passwordless approach.

Why this answer

The recommended approach is to enable a system-assigned (or user-assigned) managed identity on the Container App and grant it the AcrPull role on the Azure Container Registry. This lets the Container App authenticate to ACR without storing any credentials, using Entra ID token exchange under the hood. It is the Azure-native, secretless pattern for image pulls.

Exam trap

AI-200 often tests whether candidates default to admin credentials or SAS tokens for ACR access, when the correct Azure-native answer is always a managed identity with the AcrPull role.

How to eliminate wrong answers

Option A is wrong because hardcoding admin credentials into environment variables exposes secrets in configuration and logs, and ACR admin accounts are disabled by default for security reasons. Option C is wrong because exposing ACR publicly without authentication allows anyone to pull images and violates basic supply-chain security. Option D is wrong because an Azure Storage SAS token grants access to blob storage, not to ACR — ACR authentication uses Entra ID or ACR tokens, not storage SAS tokens.

Full explanation →

247

MCQmedium

You are deploying a distributed PyTorch training job across multiple nodes in an Azure Kubernetes Service (AKS) cluster. Which mechanism should you use to facilitate high-speed, low-latency inter-node communication required for gradient synchronization?

A.Kubenet basic networking with dynamic NAT

B.Node placement with GPU-optimized VM series (such as NDm A100 v4) and InfiniBand support

C.Azure Application Gateway Ingress Controller (AGIC)

D.Standard Azure CNI with Network Policies enabled

AnswerB

InfiniBand with NDm A100 v4 provides the RDMA fabric that carries NCCL gradient-synchronisation traffic between nodes at high bandwidth and low latency. Standard Ethernet interconnect cannot meet the all-reduce demands of distributed PyTorch training, so this placement satisfies the inter-node communication constraint.

Why this answer

Distributed PyTorch training requires high-bandwidth, low-latency inter-node communication for AllReduce gradient synchronization, and InfiniBand (via RDMA) on GPU-optimized VM series like NDm A100 v4 provides exactly that. These SKUs include dedicated InfiniBand fabric that bypasses the TCP/IP stack, delivering the microsecond latency and hundreds of Gbps throughput needed to keep GPUs from starving during gradient exchange.

Exam trap

AI-200 often tests the misconception that any Azure CNI or ingress configuration improves inter-node performance, when only RDMA-capable GPU SKUs with InfiniBand address gradient synchronization latency.

How to eliminate wrong answers

Option A is wrong because kubenet with dynamic NAT is a basic overlay network for pod IP routing and offers no RDMA or high-speed fabric, so gradient synchronization would bottleneck on standard TCP. Option C is wrong because AGIC is an L7 HTTP/HTTPS ingress controller for exposing web applications, completely unrelated to inter-node GPU communication. Option D is wrong because standard Azure CNI with Network Policies provides pod IP addressing and traffic filtering but runs over regular Ethernet with no RDMA/InfiniBand acceleration for collective operations.

Full explanation →

248

Multi-Selecteasy

You want to ensure that your Azure AI infrastructure costs are properly attributed to different business departments. Which TWO features should you configure? (Choose two)

Select 2 answers

A.Azure Key Vault cryptographic keys

B.Azure resource tags for department identification (e.g., Department=Finance)

C.Cost Analysis grouping and filtering by tag name

D.Application Insights availability probes

E.Azure Firewall network rules

AnswersB, C

Resource tags attach department metadata directly to Azure AI resources, enabling chargeback and showback. This satisfies the requirement to attribute costs by business unit, since tags flow into billing records and can be enforced through Azure Policy.

Why this answer

Resource tagging and Cost Management export/cost views help organize and attribute costs by department.

Full explanation →

249

MCQeasy

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

A.Embed the primary SAS access key into the client's application environment variables.

B.Assign the 'Event Grid Data Sender' role to the Managed Identity on the Event Grid topic resource scope.

C.Enable AMQP 1.0 token authentication on the event subscription.

D.Configure an Azure Storage firewall rule on the topic endpoint.

AnswerB

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

250

MCQeasy

Your data science team pushes container images to Azure Container Registry (ACR). You need to ensure that every image pushed is automatically scanned for known vulnerabilities before being deployed to production. Which ACR feature should you enable?

A.Microsoft Defender for Cloud vulnerability scanning

B.ACR Tasks

C.Azure Policy geo-replication rules

D.Content Trust signing

AnswerA

Microsoft Defender for Cloud vulnerability scanning integrates with ACR to automatically scan images on push, detecting known CVEs in OS packages and language dependencies. Enabling it satisfies the requirement to scan every pushed image before production deployment without altering the build pipeline.

Why this answer

Microsoft Defender for Cloud (specifically the Defender for Containers plan) integrates with ACR to automatically scan images on push and continuously rescan for newly disclosed CVEs. Findings surface as security recommendations and can gate deployment via Azure Policy. This is the native ACR vulnerability-scanning capability the question asks for.

Exam trap

The trap is confusing build automation (ACR Tasks) or signing (Content Trust) with vulnerability scanning; only Defender for Cloud performs CVE detection on pushed images.

How to eliminate wrong answers

Option B is wrong because ACR Tasks automates image builds, base-image updates, and multi-step workflows, but does not perform vulnerability scanning. Option C is wrong because Azure Policy geo-replication rules govern where registries replicate data for availability/compliance, not image scanning. Option D is wrong because Content Trust (Docker Notary) enforces image signing and integrity verification, which proves provenance but does not detect known vulnerabilities.

Full explanation →

251

MCQmedium

You are implementing vector search in Azure AI Search using the REST API. You want to execute a pure vector query without any keyword matching. What parameter must be omitted or left empty in your query request payload?

A.The 'vectorQueries' parameter

B.The 'search' parameter

C.The 'top' parameter

D.The 'api-version' parameter

AnswerB

Omitting the 'search' parameter removes keyword matching, so the query executes purely against vector fields. Leaving it empty or absent ensures only the vector query runs, satisfying the requirement for a pure vector search without hybrid keyword scoring.

Why this answer

In Azure AI Search, a pure vector query is executed by providing the 'vectorQueries' array and omitting or leaving the 'search' parameter empty (or setting it to null). When 'search' is omitted, the service performs only vector similarity search without keyword matching. This is documented behavior for vector-only queries.

Exam trap

AI-200 often tests the confusion between omitting 'search' versus omitting 'vectorQueries', causing candidates to think 'vectorQueries' should be omitted for a pure vector query when it is actually required.

How to eliminate wrong answers

Option A is wrong because 'vectorQueries' is the parameter that must be included to specify the vector query; omitting it would mean no vector search occurs. Option C is wrong because 'top' controls the number of results returned and is optional; omitting it does not make the query vector-only. Option D is wrong because 'api-version' is a required query string parameter for the REST API call and must be present; omitting it causes an error, not a vector-only query.

Full explanation →

252

Multi-Selectmedium

You are configuring an Azure AI Search vector index. Which TWO parameters are part of the HNSW algorithm configuration settings? Choose two.

Select 2 answers

A.efSearch

B.m

C.maxTokenLength

D.clusterCount

E.shingleSize

AnswersA, B

efSearch controls the size of the dynamic candidate list explored during HNSW query execution, trading recall against latency. It is a tunable HNSW parameter in Azure AI Search's vector search configuration, satisfying the stem's request for an HNSW algorithm setting.

Why this answer

Option A, efSearch, is correct because it is the HNSW parameter that controls the size of the dynamic candidate list used during query time, trading off recall against latency in Azure AI Search vector search. Option B, m, is correct because it is the HNSW parameter specifying the number of bi-directional links created for each node in the graph, which affects index build time, memory, and search accuracy. The other options do not belong: maxTokenLength and shingleSize are text-analyzer settings used in custom analyzers for lexical indexing, not vector HNSW configuration, and clusterCount is not an HNSW parameter in Azure AI Search (it relates to partitioning or clustering concepts, not the HNSW graph settings).

Exam trap

AI-200 often tests whether candidates confuse HNSW parameters (m, efSearch, efConstruction) with text-analyzer parameters (maxTokenLength, shingleSize) or exhaustive KNN parameters (clusterCount) that appear in the same index schema.

Full explanation →

253

Multi-Selecthard

Which THREE of the following are benefits of using ACR Tasks for containerized AI workloads?

Select 3 answers

A.Automatic scaling of the registry.

B.Triggering builds on base image updates.

C.Automated image building from source code.

D.Multi-step build tasks.

E.Direct deployment to Azure SQL.

AnswersB, C, D

ACR Tasks can automatically rebuild an image whenever its base image is updated in the registry, removing manual rebuild effort. This directly satisfies the stem's benefit requirement by keeping containerised AI workloads current with patched or retrained base layers, without external CI orchestration or scheduled pipelines.

Why this answer

Option B is correct because ACR Tasks can automatically trigger a rebuild of an image whenever its base image is updated in the registry, which keeps containerized AI workloads current with patched or upgraded dependencies. Option C is correct because ACR Tasks provides automated image building from source code, using a Dockerfile or buildpacks, so commits to a Git repository or source archive can produce new container images without a local Docker daemon. Option D is correct because ACR Tasks supports multi-step tasks, defined in a YAML file, that chain build, run, and push steps for complex container workflows.

Option A is not a benefit of ACR Tasks, since automatic scaling of the registry is a feature of the Azure Container Registry service tier (for example, Premium with geo-replication and throughput scaling), not of ACR Tasks. Option E is not applicable because ACR Tasks builds and manages container images; it does not directly deploy to Azure SQL, which is a relational database service rather than a container deployment target.

Exam trap

AI-200 often tests whether candidates confuse ACR Tasks (a build automation service) with registry scaling or deployment services — the distractor 'automatic scaling of the registry' sounds plausible but is not a feature of ACR Tasks.

Full explanation →

254

Multi-Selecthard

When migrating data into Azure AI Search for vector search, you encounter issues with ingestion. Which TWO of the following are valid reasons why an indexer might fail to ingest vector data?

Select 2 answers

A.The vector dimensions in the source data exceed the index field's configured dimensions.

B.The embedding model used is deprecated.

C.The 'Collection(Edm.Single)' field is marked as 'filterable'.

D.The source document contains a vector array with an incorrect field type (e.g., array of strings).

E.The indexer is not configured with an 'AzureOpenAI' skill.

AnswersA, D

Each vector field declares fixed dimensions, and every ingested vector must match exactly. Source vectors with more dimensions than the index field allows fail validation, so the indexer rejects those documents rather than truncating or padding them.

Why this answer

Option A is correct because Azure AI Search validates vector length at ingestion time: if the source vector has more (or fewer) dimensions than the index field's configured 'dimensions' value, the indexer fails with a dimension mismatch error. Option D is correct because the vector field must be defined as Collection(Edm.Single) (or another supported vector type) and the source data must supply a numeric array; an array of strings or other non-numeric type cannot be cast to the vector field and causes ingestion to fail. Option B is not a valid reason because a deprecated embedding model still produces numeric vectors that the indexer can ingest; deprecation affects the model's availability, not the indexer's type/dimension validation.

Option C is not a valid reason because marking a Collection(Edm.Single) field as 'filterable' is a supported configuration (though it consumes extra storage) and does not by itself cause ingestion failure. Option E is not a valid reason because an 'AzureOpenAI' skill is only needed to generate embeddings at index time; if the source already contains vectors, no such skill is required, and its absence does not cause an ingestion failure.

Exam trap

AI-200 often tests the misconception that embedding-model lifecycle events (deprecation) or missing enrichment skills break ingestion, when the real failure modes are schema-level: dimension mismatch and incorrect field data type.

Full explanation →

255

MCQeasy

You need to analyze log queries across multiple AI applications and infrastructure components to identify custom performance bottlenecks. Which query language is used in Azure Monitor Log Analytics to write queries against collected log data?

A.GraphQL

B.SQL Server Transact-SQL (T-SQL)

C.Kusto Query Language (KQL)

D.Azure Resource Graph Query (ARGQL)

AnswerC

KQL is the native query language of Azure Monitor Log Analytics, so it queries the collected log data across AI applications and infrastructure components. Its operators let you join and filter tables to isolate custom performance bottlenecks.

Why this answer

Kusto Query Language (KQL) is the native query language used by Azure Monitor Log Analytics to query data stored in Log Analytics workspaces. It is designed for read-only, high-performance analysis of large volumes of structured, semi-structured, and unstructured log data, making it ideal for identifying custom performance bottlenecks across AI applications and infrastructure. KQL supports advanced operators like `summarize`, `join`, `render`, and `make-series` that enable deep diagnostics and visualization.

Exam trap

AI-200 often tests the confusion between KQL and other query languages like T-SQL or ARGQL, especially when candidates assume that Azure Monitor uses SQL because of its familiarity.

How to eliminate wrong answers

Option A is wrong because GraphQL is an API query language for client-server data fetching, not for querying log data in Azure Monitor. Option B is wrong because T-SQL is used for relational databases like Azure SQL Database, not for Log Analytics; while KQL has some SQL-like syntax, it is a distinct language optimized for telemetry data. Option D is wrong because Azure Resource Graph Query (ARGQL) is used to query and explore Azure resources at scale via Azure Resource Graph, not for analyzing log data in Log Analytics workspaces.

Full explanation →

256

MCQhard

You are optimizing a large language model container inference deployment on AKS using GPU-enabled nodes (NC-series). The inference server experiences frequent out-of-memory errors on the GPU device itself during high context lengths. Which Kubernetes configuration metric should you monitor and alert on?

A.container_memory_working_set_bytes via kubelet

B.container_cpu_cfs_throttled_periods_total

C.node_net_bytes_total

D.container_gpu_memory_used_bytes via NVIDIA DCGM Exporter

AnswerD

container_gpu_memory_used_bytes, exposed by NVIDIA DCGM Exporter, reports actual GPU device memory consumption. Monitoring it directly detects the high-context-length memory pressure causing device-level out-of-memory errors, unlike node-level or CPU metrics which cannot reveal GPU memory exhaustion.

Why this answer

GPU out-of-memory errors on the device itself must be detected by monitoring GPU memory utilization, which is exposed by the NVIDIA DCGM Exporter as container_gpu_memory_used_bytes (and related DCGM metrics like DCGM_FI_DEV_FB_USED). This metric reflects actual framebuffer memory consumption on the GPU, which is what causes CUDA OOM errors during long-context inference.

Exam trap

The trap is conflating container memory (RAM) with GPU device memory — candidates pick container_memory_working_set_bytes because it sounds like 'memory used,' missing that GPU OOM requires a DCGM/NVIDIA-specific metric.

How to eliminate wrong answers

Option A is wrong because container_memory_working_set_bytes measures host/container RAM (system memory), not GPU framebuffer memory — a pod can have low working set and still OOM on the GPU. Option B is wrong because container_cpu_cfs_throttled_periods_total measures CPU scheduling throttling, which is unrelated to GPU memory exhaustion. Option C is wrong because node_net_bytes_total is a network throughput metric and has no bearing on GPU memory.

Full explanation →

257

MCQeasy

Which Azure AI Search field property indicates whether the contents of a field can be returned in search query result documents?

A.searchable

B.facetable

C.retrievable

D.filterable

AnswerC

The retrievable property controls whether a field's contents are returned in search results. Setting it to true includes the field in result documents; false keeps it indexed and searchable but omitted from the returned payload.

Why this answer

In Azure AI Search, the 'retrievable' attribute controls whether a field's contents are returned in search results. If retrievable is false, the field can still be searched, filtered, or sorted but its value is omitted from the returned document. This is the exact property that governs result payload inclusion.

Exam trap

The trap is conflating 'searchable' with 'retrievable' — candidates assume a field that can be searched is automatically returned, but Azure AI Search decouples indexing from result projection.

How to eliminate wrong answers

Option A is wrong because 'searchable' controls whether the field is full-text indexed and can be matched in queries — it does not govern whether the value is returned. Option B is wrong because 'facetable' enables the field to be used in faceted navigation for filtering and counting, unrelated to result retrieval. Option D is wrong because 'filterable' allows the field to be used in $filter expressions, which is about query constraints, not result content.

Full explanation →

258

MCQmedium

You are implementing a multi-modal AI application that searches across both text descriptions and product images stored in Azure AI Search. Which feature allows you to query both modalities within a unified search index?

A.Single-dimension global vector index restriction

B.Mandatory unification of text and image vectors into a single 1536-dimensional field

C.External fusion proxy service

D.Multiple vector fields with distinct dimensions and vectorizers in a single index

AnswerD

Multiple vector fields let one index hold text embeddings and image embeddings side by side, each with its own dimensions, while vectorizers generate embeddings at query time. This satisfies the unified cross-modality query requirement, which a single vector field cannot accommodate.

Why this answer

Azure AI Search supports defining multiple vector fields in a single index, each with its own dimensions and vectorizer, so text embeddings (e.g., 1536-dim from text-embedding-ada-002) and image embeddings (e.g., 512-dim from a CLIP-style model) can coexist and be queried together. This enables unified multi-modal search where a query can target both text and image vector fields, with results merged via hybrid or RRF ranking.

Exam trap

AI-200 often tests whether candidates believe Azure AI Search requires a single unified vector dimension — the trap is assuming all vectors must share dimensionality, when the service actually supports multiple vector fields with distinct dimensions and vectorizers.

How to eliminate wrong answers

Option A is wrong because Azure AI Search does not impose a single-dimension global vector index restriction; indexes can contain multiple vector fields with different dimensions. Option B is wrong because there is no requirement to unify text and image vectors into one 1536-dimensional field — forcing different modalities into a shared dimension is neither required nor generally desirable, since each modality's embedding model has its own native dimensionality. Option C is wrong because no external fusion proxy service is needed; Azure AI Search natively supports multiple vector fields and hybrid ranking within a single index.

Full explanation →

259

MCQeasy

You need to monitor the monthly cost of an Azure AI Document Intelligence resource to ensure it does not exceed a specified budget. Where should you configure an automated notification when the cost reaches 80% of the budget?

A.Configure an alert rule in Azure Monitor on the Document Intelligence resource metric 'Transactions'.

B.Set up an action group in Azure Advisor to monitor billing anomalies.

C.Create a Budget in Azure Cost Management + Billing with an alert threshold set to 80%.

D.Create an expenditure alert inside the Azure AI Foundry portal.

AnswerC

Azure Cost Management budgets evaluate spend against a defined scope and trigger alerts at configured thresholds. Setting 80% on the budget notifies the team before the limit is breached, meeting the requirement for automated notification at that percentage.

Why this answer

Azure Cost Management + Billing Budgets are the native mechanism for setting spending thresholds and triggering automated notifications (email or action groups) when actual or forecasted cost reaches a defined percentage of the budget. Setting an 80% threshold on a budget scoped to the Document Intelligence resource is the correct approach.

Exam trap

AI-200 often tests the difference between cost governance (Budgets in Cost Management) and usage monitoring (Azure Monitor metric alerts) — candidates pick metric alerts on 'Transactions' thinking it tracks cost, when only Budgets track monetary spend.

How to eliminate wrong answers

Option A is wrong because Azure Monitor alert rules on the 'Transactions' metric track usage volume, not monetary cost — a transaction count alert does not map to a dollar budget and cannot enforce a cost threshold. Option B is wrong because Azure Advisor provides recommendations, not billing anomaly monitoring, and action groups are notification mechanisms, not budget monitors. Option D is wrong because Azure AI Foundry does not have a native 'expenditure alert' feature for individual AI resources — cost governance is centralized in Cost Management + Billing.

Full explanation →

260

MCQeasy

You need to store sensitive database connection strings and AI API keys used by containerized applications running in Azure Container Apps. Which feature should you use to securely store and reference these values?

A.A standard DNS TXT record

B.Container App Secrets

C.Azure Storage account public blob container

D.Plain text Dockerfile ENV directives

AnswerB

Container App Secrets store encrypted values at the application level and expose them to containers as environment variables or volume-mounted references, keeping connection strings and API keys out of images and source control. This satisfies the secure storage and reference requirement.

Why this answer

Container App Secrets provide an encrypted, managed store for sensitive values such as connection strings and API keys, and they can be referenced from environment variables or volume mounts without exposing the plaintext in the app definition. They are scoped to the Container App and integrated with the platform's secret management, making them the correct secure storage mechanism.

Exam trap

AI-200 often tests the misconception that environment variables in the container definition are secure, when only Container App Secrets (or Key Vault references) provide encrypted, redacted storage.

How to eliminate wrong answers

Option A is wrong because a DNS TXT record is publicly resolvable and provides no confidentiality or access control, exposing secrets to anyone who queries the record. Option C is wrong because a public blob container allows anonymous read access, directly leaking the secrets to the internet. Option D is wrong because Dockerfile ENV directives bake plaintext secrets into the image layers, where they persist in the registry and are visible to anyone with image pull access.

Full explanation →

261

MCQmedium

You are optimizing search performance in Azure AI Search. You notice that vector queries are consuming excessive memory and slowing down. You decide to enable exhaustive k-NN fallback for specific queries. What does exhaustive k-NN do?

A.It compresses the vector index by 50%

B.It shards the index across multiple search units

C.It searches all vectors exactly without relying on an approximate nearest neighbor graph

D.It caches query results in Redis

AnswerC

Exhaustive k-NN performs a brute-force comparison against every vector in the index, bypassing the approximate nearest neighbour graph entirely. This guarantees exact recall for the specified queries, at the cost of higher latency and memory consumption.

Why this answer

Exhaustive k-NN (also called brute-force or exact k-NN) computes the distance between the query vector and every vector in the index, returning the exact nearest neighbors without relying on an approximate graph like HNSW. It is used when recall must be perfect, at the cost of higher latency and memory.

Exam trap

AI-200 often tests the misconception that exhaustive k-NN is a performance optimization — the trap is forgetting that it trades speed for exactness, and is used when recall matters more than latency.

How to eliminate wrong answers

Option A is wrong because exhaustive k-NN does not compress the index; compression is a separate concern (e.g., scalar quantization). Option B is wrong because sharding is a partitioning strategy, not what exhaustive k-NN does. Option D is wrong because caching in Redis is an external optimization, not a function of exhaustive k-NN.

Full explanation →

262

MCQeasy

Which command-line interface tool is used to deploy and manage container images directly to Azure Container Registry?

A.helm.

B.docker build.

C.az acr.

D.kubectl.

AnswerC

The az acr command group within the Azure CLI provides dedicated operations for building, pushing, importing and managing container images in Azure Container Registry, meeting the need to deploy and manage images directly against the registry.

Why this answer

The Azure CLI command group 'az acr' is specifically designed to manage Azure Container Registry, including building, pushing, and pulling container images directly to/from ACR. It provides native integration with ACR and supports tasks like creating registries, managing credentials, and running ACR Tasks. This makes it the correct tool for deploying and managing container images directly to ACR.

Exam trap

AI-200 often tests the difference between general container tools (Docker, Helm, kubectl) and Azure-specific management tools (az acr), causing candidates to choose a tool that builds images locally but does not directly manage ACR.

How to eliminate wrong answers

Option A is wrong because Helm is a package manager for Kubernetes, used to deploy applications, not to manage container images in ACR. Option B is wrong because 'docker build' builds images locally but does not deploy or manage them in ACR; you would still need 'docker push' or 'az acr' to push. Option D is wrong because kubectl is a Kubernetes command-line tool for managing clusters, not for directly managing container images in ACR.

Full explanation →

263

MCQmedium

You are configuring semantic ranking in Azure AI Search. You need to specify which fields in your index contain the title and content that the semantic ranker should analyze. Where do you configure these field mappings?

A.In the indexer skill set cognitive map

B.In the Azure OpenAI model deployment properties

C.In the semantic configuration section of the index schema

D.In the vector profile definition

AnswerC

Semantic ranking requires a semantic configuration declared in the index schema, where you name the title, content and keyword fields the ranker should analyse. Defining these field mappings there satisfies the stem's requirement to specify which index fields feed the semantic ranker.

Why this answer

Semantic ranking in Azure AI Search is configured in the semantic configuration section of the index schema. Within this configuration, you specify which fields contain the title, content, and keywords that the semantic ranker should analyze. This is done by defining a semantic configuration object in the index definition.

Exam trap

AI-200 often tests where to configure semantic ranking fields. Candidates might confuse it with indexer skillsets or vector profiles, but it's specifically in the index schema's semantic configuration.

How to eliminate wrong answers

Option A is wrong because the indexer skill set cognitive map is used for AI enrichment during indexing, not for semantic ranking configuration. Option B is wrong because Azure OpenAI model deployment properties are unrelated to Azure AI Search semantic ranking. Option D is wrong because the vector profile definition is used for vector search configuration, not semantic ranking.

Full explanation →

264

MCQmedium

Your machine learning engineering team needs to run training jobs on Azure Machine Learning compute clusters. To minimize costs during off-peak hours, you need to configure the compute cluster to automatically scale down to zero nodes when no jobs are queued, and scale up when jobs are submitted. What setting should you configure on the compute cluster?

A.Set the minimum number of nodes to 0 and the maximum nodes according to workload requirements

B.Configure Azure Automation runbooks to stop the physical datacenter servers

C.Set the minimum number of nodes equal to the maximum number of nodes

D.Use Azure Functions timer triggers to delete the compute target every evening

AnswerA

Setting minimum nodes to 0 lets the cluster deprovision all compute when idle, while the maximum caps scale-up for queued jobs. This satisfies the stem's scale-to-zero cost requirement, since Azure ML scales nodes down automatically when no jobs are pending.

Why this answer

To automatically scale down to zero nodes when no jobs are queued and scale up when jobs are submitted, you should set the minimum number of nodes to 0 and the maximum nodes according to workload requirements. Azure Machine Learning compute clusters support autoscaling with a minimum of 0, which allows the cluster to deallocate all nodes when idle, minimizing costs. When a job is submitted, the cluster automatically scales up to the maximum node count to handle the workload.

Exam trap

AI-200 often tests the misconception that autoscaling to zero requires deleting the cluster or using external automation, when in fact setting min_nodes to 0 is the built-in, supported configuration.

How to eliminate wrong answers

Option B is wrong because configuring Azure Automation runbooks to stop physical datacenter servers is not applicable to Azure ML compute clusters, which are virtual and managed by Azure; you cannot stop physical servers. Option C is wrong because setting the minimum equal to the maximum disables autoscaling, resulting in a fixed-size cluster that cannot scale down to zero, leading to unnecessary costs. Option D is wrong because using Azure Functions timer triggers to delete the compute target every evening is a manual, disruptive approach that would delete the cluster and require recreation, losing configuration and causing delays; it is not the built-in autoscaling feature.

Full explanation →

265

Multi-Selecthard

You are configuring comprehensive observability for an intelligent application built on Azure AI Document Intelligence and Azure OpenAI. Which THREE telemetry types or tools should you configure in Application Insights to capture complete operational insights? (Choose three)

Select 3 answers

A.Configure dependency tracking to monitor outgoing HTTP calls made to Azure AI REST endpoints.

B.Track custom events to log domain-specific metrics like document processing success rates.

C.Install the Azure Firewall policy manager directly onto the Application Insights SDK.

D.Enable exception telemetry to automatically capture unhandled runtime errors and stack traces.

E.Use Azure Active Directory conditional access policies to restart unhealthy worker threads.

AnswersA, B, D

Dependency tracking records outgoing HTTP calls to Azure AI REST endpoints, capturing latency, response codes and failure rates for Document Intelligence and Azure OpenAI. This satisfies the observability requirement by exposing downstream service performance, which request telemetry alone cannot attribute to specific external dependencies.

Why this answer

Option A is correct because Application Insights dependency tracking automatically captures outgoing HTTP/REST calls to Azure AI Document Intelligence and Azure OpenAI endpoints, recording duration, result codes, and failures so you can diagnose latency and errors in the AI service calls. Option B is correct because custom events let you log domain-specific telemetry such as document processing success rates, which are not captured by default request/dependency metrics and are essential for business-level observability. Option D is correct because exception telemetry automatically captures unhandled runtime errors with stack traces, enabling root-cause analysis of failures in the application code.

Option C is incorrect because Azure Firewall policy management is a networking security function and cannot be installed into the Application Insights SDK. Option E is incorrect because Azure AD conditional access policies govern authentication/authorization and cannot restart unhealthy worker threads.

Exam trap

AI-200 often tests whether candidates can identify the three core telemetry types (dependencies, custom events, exceptions) and avoid distractors that mix in unrelated Azure services like Firewall or Conditional Access.

Full explanation →

266

MCQmedium

You are configuring an Azure AI Search index schema via the REST API. You need to define a field that will hold a 1536-dimensional vector. Which field type must you assign to this field?

A.Edm.Vector

B.Edm.SingleCollection

C.Edm.String

D.Edm.DoubleCollection

AnswerB

Edm.SingleCollection stores a collection of single-precision floats, which is exactly what a 1536-dimensional embedding requires. Azure AI Search represents vector fields as arrays of Edm.Single, so this type satisfies the stem's dimensional constraint. Edm.Single alone holds one float, and Edm.DoubleCollection would waste space and break vector search compatibility.

Why this answer

In Azure AI Search, vector fields are defined using the Edm.SingleCollection type, which represents a collection of single-precision floating-point values — the standard representation for embeddings. A 1536-dimensional vector (e.g., from text-embedding-ada-002) is declared as Edm.SingleCollection with dimensions set to 1536 and a vectorSearchProfile attached. There is no Edm.Vector type in the Azure AI Search schema.

Exam trap

AI-200 often tests the misconception that a generic 'Edm.Vector' type exists; the exam expects you to know the actual collection types (Single, Half, Byte) and that dimensions are immutable.

How to eliminate wrong answers

Option A is wrong because Edm.Vector is not a valid Azure AI Search field type — candidates often assume a generic 'vector' type exists, but the actual types are Edm.SingleCollection, Edm.HalfCollection, and Edm.ByteCollection. Option C is wrong because Edm.String stores text and cannot be used for vector similarity search; embeddings must be numeric collections. Option D is wrong because Edm.DoubleCollection stores 64-bit doubles, which are not used by Azure AI Search vector fields and would double memory usage without benefit — embeddings are single-precision.

Full explanation →

267

Multi-Selecthard

You are troubleshooting a performance degradation in an Azure Cosmos DB for NoSQL vector search application. Which THREE diagnostic steps or metrics should you inspect? (Choose three)

Select 3 answers

A.Normalized RU consumption across physical partitions to check for hot spotting

B.Azure Blob Storage tier status (Hot vs Cool)

C.App Service SSL certificate expiration date

D.Request Unit (RU) charge per query response header

E.Index transformation progress to ensure vector indexing is fully completed

AnswersA, D, E

Normalized RU consumption reveals whether logical partition traffic concentrates on one physical partition, causing hot spotting that throttles vector queries. Inspecting this metric satisfies the diagnostic requirement by exposing uneven partition key distribution as the degradation's root cause.

Why this answer

Option A is correct because Normalized RU consumption across physical partitions is the key Azure Cosmos DB metric for detecting hot spotting; if one physical partition consistently shows much higher normalized RU usage than others, vector search throughput is throttled by that partition. Option D is correct because the RU charge returned in each query response header (x-ms-request-charge) reveals the actual cost of each vector query, letting you identify expensive queries and compare them against provisioned throughput. Option E is correct because vector indexing in Cosmos DB for NoSQL is performed by an index transformation, and if that transformation is still in progress or stuck, vector queries may scan more data, return incomplete results, or run slower, so checking index transformation progress is essential.

Option B is not relevant because Blob Storage access tiers (Hot vs Cool) affect blob storage cost and latency, not Cosmos DB vector query performance. Option C is not relevant because App Service SSL certificate expiration affects HTTPS connectivity to a web app, not the internal performance of Cosmos DB vector search.

Exam trap

AI-200 often tests whether candidates can distinguish Cosmos DB-specific performance metrics from unrelated Azure service metrics; the trap is selecting plausible-sounding but irrelevant options like Blob tier or SSL expiry that have nothing to do with RU-based vector query performance.

Full explanation →

268

MCQmedium

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

A.Event Grid Standard tier

B.Event Grid Basic tier

C.Event Grid Basic tier with custom schema extensions

D.Event Grid Premium tier

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

269

MCQmedium

Your enterprise AI application is deployed across multiple Azure regions for high availability. You need to ensure that logs from Application Insights instances in all regions are aggregated into a single central Log Analytics workspace for unified querying. How should you configure this?

A.Configure each Application Insights resource to use the same shared centralized Log Analytics workspace during creation

B.Deploy a separate Log Analytics workspace in every region and use Azure Backup to copy tables

C.Write a custom Python script that downloads logs from each region every hour and uploads them to Azure Blob Storage

D.Use Azure Traffic Manager to merge log data streams at the DNS level

AnswerA

Application Insights resources can be directed to a workspace-based configuration, where each regional resource writes its telemetry into one shared Log Analytics workspace. Pointing every regional instance at the same workspace at creation satisfies the stem's requirement for centralised, cross-region querying.

Why this answer

Application Insights resources can be configured to send their telemetry to a Log Analytics workspace, and pointing multiple regional Application Insights instances at the same workspace aggregates all logs for unified KQL querying. This is done at creation time (or via migration) by selecting the shared workspace as the ingestion target. The result is a single pane of glass across regions without custom ETL.

Exam trap

AI-200 often tests the belief that separate regional workspaces can be 'merged' by a networking service, when the correct approach is to point all Application Insights resources at one shared workspace from the start.

How to eliminate wrong answers

Option B is wrong because Azure Backup protects data; it cannot copy Log Analytics tables between workspaces, and separate workspaces defeat the goal of unified querying. Option C is wrong because a custom Python download-and-upload script is brittle, introduces latency, and Blob Storage is not a queryable Log Analytics workspace, so it does not achieve centralized querying. Option D is wrong because Azure Traffic Manager is a DNS-based traffic distribution service; it has no ability to merge or store log data streams.

Full explanation →

270

MCQhard

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

A.Enable Geo-Disaster Recovery to force the secondary region to sync historical logs.

B.Delete the existing consumer group and recreate it with a 2-hour retention limit.

C.Purge all messages from the Event Hub using the Azure CLI az eventhubs purge command.

D.Create a new temporary consumer group and initialize the event receiver with a custom starting offset based on enqueued timestamp.

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

271

MCQhard

You are deploying a high-performance AI model in AKS. You need to ensure the container has access to the underlying host's NVIDIA GPU. What must be configured in the Pod spec?

A.Mount the host path '/dev/nvidia0'.

B.Use an InitContainer to install the driver.

C.Set 'privileged: true' in the security context.

D.Define a Resource Request for 'nvidia.com/gpu'.

AnswerD

Requesting 'nvidia.com/gpu' as a resource limit in the container spec triggers the NVIDIA device plugin to allocate a host GPU and mount the driver libraries. This satisfies the requirement that the container accesses the underlying host NVIDIA GPU.

Why this answer

To give a container access to an NVIDIA GPU in Kubernetes/AKS, you must declare a resource request (and typically a limit) for `nvidia.com/gpu` in the container spec. The NVIDIA device plugin on the node advertises GPUs as extended resources, and the scheduler uses this request to bind the pod to a GPU-equipped node and allocate the device.

Exam trap

AI-200 often tests the difference between host-level GPU access (mounting devices, privileged mode) and Kubernetes-native resource requests, tricking candidates who pick low-level workarounds.

How to eliminate wrong answers

Option A is wrong because mounting `/dev/nvidia0` directly bypasses the device plugin, does not properly allocate or isolate the GPU, and is not how Kubernetes manages GPU resources — it can also cause conflicts between pods. Option B is wrong because installing the driver via an InitContainer is not the mechanism for GPU access; the NVIDIA driver must be installed on the host (AKS GPU node pools handle this), and the device plugin exposes the GPU. Option C is wrong because `privileged: true` grants broad host access but does not allocate a GPU as a schedulable resource — it is a security risk and not the correct GPU access method.

Full explanation →

272

MCQmedium

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

A.Azure Event Grid

B.Azure Notification Hubs

C.Azure Service Bus

D.Azure Event Hubs

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

273

MCQmedium

You are setting up auto-scaling for a containerized AI web app in Azure Container Apps. You want to scale based on the number of concurrent HTTP requests. Which scaler do you use?

A.Azure Service Bus scaler.

B.HTTP scaler.

C.CPU usage scaler.

D.Memory usage scaler.

AnswerB

The HTTP scaler scales replicas based on the number of concurrent HTTP requests reaching the app, which matches the stated concurrency metric. It reads request counts directly, so scaling responds to actual traffic load rather than CPU or memory usage.

Why this answer

The HTTP scaler in Azure Container Apps scales replicas based on the number of concurrent HTTP requests, which directly matches the requirement to scale on concurrent HTTP request count. It is a KEDA-based scaler configured in the container app's scale rules with a `concurrentRequests` threshold.

Exam trap

The trap is that candidates may choose CPU or memory scalers because they assume resource utilization is the best proxy for load, but AI-200 tests the specific scaler type that directly measures HTTP concurrency.

How to eliminate wrong answers

Option A is wrong because the Azure Service Bus scaler scales on message queue length or topic subscription backlog, which is appropriate for asynchronous messaging, not concurrent HTTP requests. Option C is wrong because CPU usage reflects compute consumption inside the container, not the number of simultaneous inbound HTTP connections, and it may lag behind actual request concurrency. Option D is wrong because memory usage is a resource metric that does not correlate directly with HTTP request concurrency and can be affected by caching or leaks unrelated to traffic.

Full explanation →

274

Multi-Selectmedium

When configuring Azure Monitor alerts for an AI application, which TWO action types can be included in an Action Group to notify operations personnel? (Choose two)

Select 2 answers

A.Direct formatting of Azure billing invoices

B.Automated deletion of Azure subscription resources

C.Webhook integration to trigger automated incident creation in ITSM tools

D.Email / SMS / Push notifications

E.Local BIOS firmware updates for physical hypervisors

AnswersC, D

A webhook action posts alert payloads to an external HTTPS endpoint, letting the Action Group call an ITSM tool's API to open an incident automatically. This satisfies the stem's requirement to notify operations personnel indirectly through their existing ticketing workflow.

Why this answer

Action groups support multiple notification channels including email, SMS, push notifications, and webhooks.

Full explanation →

275

MCQeasy

You are configuring a hybrid search in Azure AI Search. You want to combine results from a vector search and a keyword-based search. Which feature is specifically designed to normalize scores from these different retrieval methods into a single ranked list?

A.BM25 Scoring

B.Semantic Ranker

C.Vector Normalization

D.Reciprocal Rank Fusion (RRF)

AnswerD

RRF merges the vector and keyword result sets by scoring each document from its rank position in each list, then summing those reciprocal ranks. This normalises incomparable similarity and BM25 scores into one fused ranking, satisfying the stem's single ranked list requirement.

Why this answer

Reciprocal Rank Fusion (RRF) is the specific algorithm Azure AI Search uses to merge results from parallel vector (kNN) and keyword (BM25) queries in a hybrid search. It converts each document's rank in each result set into a reciprocal score (1/(k + rank)) and sums them, producing a single unified ranked list without needing to normalize the raw, incomparable scores from BM25 and cosine similarity.

Exam trap

AI-200 often tests the distinction between the fusion algorithm (RRF) and the optional reranking layer (Semantic Ranker), causing candidates to pick 'Semantic Ranker' when asked about score normalization.

How to eliminate wrong answers

Option A is wrong because BM25 is the keyword-scoring algorithm used for the text leg of the hybrid query, not a fusion mechanism — it produces lexical relevance scores that are not comparable to vector similarity scores. Option B is wrong because the Semantic Ranker is an optional L2 reranking layer applied after RRF fusion using a language model, not the score-normalization step itself. Option C is wrong because 'Vector Normalization' is not an Azure AI Search feature — it describes a preprocessing technique (e.g., L2-normalizing embeddings) applied to vectors before indexing, not a cross-retriever fusion algorithm.

Full explanation →

276

MCQeasy

You want to ensure that no AI services can be created in unauthorized Azure regions across your entire subscription. Which Azure governance tool should you use to enforce this restriction?

A.Azure Monitor action groups

B.Azure Cost Management budgets

C.Azure Policy with the 'Allowed locations' definition

D.Azure Security Center JIT access

AnswerC

Azure Policy's built-in 'Allowed locations' definition evaluates resource creation requests against a permitted region list and denies non-compliant deployments. Assigning it at subscription scope enforces the restriction across every AI service, satisfying the requirement to block creation in unauthorised regions.

Why this answer

Azure Policy with the built-in 'Allowed locations' definition restricts resource creation to approved Azure regions at the subscription or management group scope, enforcing the restriction across all AI services. Assigning this policy denies deployments in unauthorized regions.

Exam trap

AI-200 often tests whether candidates confuse monitoring/cost/security tools with governance enforcement — only Azure Policy can deny resource creation in unauthorized regions.

How to eliminate wrong answers

Option A is wrong because Azure Monitor action groups trigger notifications or automated actions in response to alerts, not governance restrictions on resource creation. Option B is wrong because Cost Management budgets track and alert on spending, not regional deployment permissions. Option D is wrong because Security Center (Defender for Cloud) JIT access manages temporary VM port access, not region restrictions for AI services.

Full explanation →

277

MCQmedium

You have a large collection in Azure Cosmos DB for NoSQL and want to perform a vector search. The application is currently hitting 'Request Rate Too Large' (429) errors during vector search queries. What is the most effective way to mitigate this?

A.Reduce the number of vectors stored in each document.

B.Scale up the throughput (RU/s) allocated to the container.

C.Implement client-side caching of vector search results.

D.Switch the index type to 'DiskANN'.

AnswerB

Vector search consumes substantial request units, so 429 errors indicate the container's provisioned RU/s is exhausted. Scaling up throughput raises the available RU/s, directly relieving the rate limiting that the vector search queries trigger, which is the constraint named in the stem.

Why this answer

'Request Rate Too Large' (HTTP 429) in Cosmos DB means the container's provisioned or autoscale RU/s has been exhausted by the vector search workload. The most direct and effective mitigation is to increase the throughput allocated to the container so that the RU cost of vector queries is covered without throttling.

Exam trap

AI-200 often tests whether candidates conflate throughput throttling (429) with index-type or data-modeling issues, tempting them to pick 'switch to DiskANN' when the real fix is scaling RU/s.

How to eliminate wrong answers

Option A is wrong because reducing the number of vectors per document changes data modeling but does not address the throughput ceiling — queries would still be throttled if RU/s is insufficient. Option C is wrong because client-side caching reduces the number of queries but does not fix the underlying RU/s shortage for the queries that do execute, and cache misses still hit the throttled container. Option D is wrong because switching to DiskANN changes the vector index algorithm (affecting latency and recall), not the RU/s budget; 429 errors are a throughput issue, not an index-type issue.

Full explanation →

278

Multi-Selectmedium

When configuring vector search in Azure Cosmos DB for NoSQL, which TWO components must be defined within the container's indexing policy? (Choose two)

Select 2 answers

A.fullTextPolicy

B.vectorEmbeddingPolicy

C.vectorIndexes

D.spatialIndexes

E.partitionKeyDefinition

AnswersB, C

The vectorEmbeddingPolicy defines the embedding paths, dimensions and similarity metric, so Cosmos DB knows how to index and query vector data. Without it, vector search cannot function, satisfying the requirement that the indexing policy declares the vector configuration.

Why this answer

Option B (vectorEmbeddingPolicy) is correct because the container's indexing policy must declare the vector embedding policy, which defines the vector paths, data type (e.g., float32), dimensions, and distance function (cosine, dotproduct, or euclidean) so Cosmos DB knows how to interpret and compare the stored embeddings. Option C (vectorIndexes) is also correct because the indexing policy must include a vectorIndexes section that specifies the vector path and the index type (flat, quantizedFlat, or diskANN) used to perform the similarity search. Together, vectorEmbeddingPolicy and vectorIndexes are the two required elements inside the indexing policy for vector search on Azure Cosmos DB for NoSQL.

Option A (fullTextPolicy) is incorrect because it relates to full-text search (full-text indexing and scoring), not vector search. Option D (spatialIndexes) is incorrect because it configures geospatial indexing for GeoJSON data, which is unrelated to vector similarity. Option E (partitionKeyDefinition) is incorrect because the partition key is defined at the container level, not within the indexing policy.

Exam trap

AI-200 often tests the confusion between vectorEmbeddingPolicy and vectorIndexes — candidates pick one and forget the other, or mistakenly select fullTextPolicy because it sounds related to search indexing.

Full explanation →

279

MCQmedium

Your team is developing an AI solution that uses Azure Cognitive Services. You need to ensure that the API keys cannot be extracted from the client-side mobile application. What is the recommended architectural pattern to achieve this?

A.Use Azure Front Door to strip API keys from incoming mobile requests

B.Implement a backend API proxy (e.g., Azure Functions or API Management) that authenticates mobile clients and calls Cognitive Services using secure server-side keys

C.Store the Cognitive Services API key in an encrypted local SQLite database on the mobile device

D.Configure Cognitive Services for anonymous public access and rely on mobile app version checks

AnswerB

Routing Cognitive Services calls through a backend proxy keeps the subscription key server-side, so it never ships in the mobile binary where decompilation would expose it. The proxy authenticates clients via Microsoft Entra ID and forwards requests, satisfying the stem's requirement that keys cannot be extracted from the client application.

Why this answer

A backend API proxy (Azure Functions or API Management) is the recommended pattern because the Cognitive Services subscription key stays server-side and is never shipped in the mobile binary, where it could be decompiled or intercepted. The mobile client authenticates to the proxy (e.g., via OAuth 2.0/Entra ID token), and the proxy validates that identity before calling Cognitive Services with the secret key. This also enables rate limiting, key rotation, and per-user quota enforcement without redeploying the app.

Exam trap

AI-200 often tests the misconception that client-side encryption or edge services like Front Door can protect secrets, when the only robust answer is to keep the key server-side behind an authenticated proxy.

How to eliminate wrong answers

Option A is wrong because Azure Front Door is a layer-7 edge router/CDN that forwards requests; it does not authenticate mobile users or hold Cognitive Services keys on their behalf, and 'stripping' keys from requests would not prevent keys embedded in the app from being extracted. Option C is wrong because any key stored on a mobile device — even in an encrypted SQLite database — is recoverable by an attacker with device access or via reverse engineering, since the decryption key must also reside on the device. Option D is wrong because anonymous public access to Cognitive Services exposes the endpoint to abuse and cost overruns, and app version checks are client-side controls that can be bypassed trivially.

Full explanation →

280

MCQeasy

When storing vector embeddings in Azure Cosmos DB for MongoDB (vCore), which distance metric is natively supported when creating a vector search index?

A.Levenshtein distance

B.Jaccard distance

C.Hamming distance

D.Cosine distance (cos)

AnswerD

Cosine distance is natively supported by Azure Cosmos DB for MongoDB (vCore) vector indexes, satisfying the stem's requirement for a natively supported metric. It measures angular similarity between embeddings, ignoring magnitude, which suits normalised text embeddings. The alternative metrics, such as Euclidean or dot product, are not offered natively here.

Why this answer

Azure Cosmos DB for MongoDB (vCore) natively supports cosine distance when creating a vector index, specified as 'cos' in the index definition. Cosine distance measures the angle between vectors and is the standard metric for text embeddings, which are typically normalized. This makes it the correct native metric for vector search indexes in that service.

Exam trap

AI-200 often tests whether candidates know the exact set of distance metrics supported by each Azure vector store, luring them toward generic string metrics like Levenshtein or Jaccard that sound plausible but are not vector index options.

How to eliminate wrong answers

Option A is wrong because Levenshtein distance measures edit distance between strings and is not a vector similarity metric supported by Cosmos DB vector indexes. Option B is wrong because Jaccard distance measures set dissimilarity and is not a supported vector index metric in Cosmos DB for MongoDB vCore. Option C is wrong because Hamming distance counts differing positions in equal-length strings and is not a native vector index metric for this service.

Full explanation →

281

MCQeasy

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

A.AbandonAsync

B.DeadLetterAsync

C.RenewLockAsync

D.CompleteAsync

AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

282

Multi-Selecteasy

You want to monitor the security posture and compliance score of your Azure AI resources. Which TWO of the following tools should you use? (Choose two)

Select 2 answers

A.Azure Container Registry storage tiers

B.Azure DNS zone editor

C.Azure Cost Management for billing forecasts

D.Azure Policy compliance dashboard for regulatory standard evaluations

E.Microsoft Defender for Cloud for security recommendations and secure score

AnswersD, E

Azure Policy's compliance dashboard continuously evaluates resources against built-in regulatory initiatives, such as ISO 27001 and NIST, surfacing per-resource compliance states and remediation tasks. This directly satisfies the stem's requirement to monitor the compliance score of Azure AI resources, since regulatory standard evaluations are exactly what the dashboard reports.

Why this answer

Option D is correct because the Azure Policy compliance dashboard evaluates resources against built-in and custom policy definitions, including regulatory standard initiatives such as ISO 27001, NIST SP 800-53, and PCI DSS, and reports each resource's compliance state, which directly addresses monitoring the compliance score of Azure AI resources. Option E is correct because Microsoft Defender for Cloud continuously assesses Azure resources, including AI services, against security benchmarks and surfaces security recommendations plus a Secure Score that quantifies the overall security posture. The two together cover the compliance dimension (Azure Policy) and the security-posture dimension (Defender for Cloud) requested in the scenario.

Option A is incorrect because Azure Container Registry storage tiers only control image storage performance and cost, not security or compliance evaluation. Option B is incorrect because the Azure DNS zone editor manages DNS records and has no role in security posture or regulatory compliance scoring. Option C is incorrect because Azure Cost Management provides billing and cost forecasting data, not security recommendations or compliance assessments.

Exam trap

The trap is selecting cost or operational tools (Cost Management, Container Registry) when asked about security posture; candidates must distinguish security/compliance tools (Defender for Cloud, Azure Policy) from billing and infrastructure management tools.

Full explanation →

283

MCQhard

You notice that your AKS pods are stuck in 'ContainerCreating' state. You check the events and see 'FailedMount'. What is the most likely cause?

A.The node is out of CPU resources.

B.The container crashed immediately.

C.The container image is too large.

D.The associated Persistent Volume Claim (PVC) is missing or cannot be bound.

AnswerD

FailedMount events occur when the kubelet cannot attach or mount the volume backing a pod. A missing or unbound Persistent Volume Claim leaves no storage to mount, so the pod remains in ContainerCreating. This matches the observed event rather than image or scheduling faults.

Why this answer

A 'FailedMount' event during the ContainerCreating phase almost always indicates that the pod's volume mount could not be satisfied — most commonly because the PersistentVolumeClaim (PVC) is missing, in a Pending state, or cannot bind to an available PersistentVolume. Since the container hasn't started yet, the failure is at the storage attachment stage, not at runtime. This is the classic signature of a PVC/PV binding problem in AKS.

Exam trap

AI-200 often tests whether candidates can distinguish between scheduling failures (Pending), image pull failures (ImagePullBackOff), runtime crashes (CrashLoopBackOff), and volume mount failures (FailedMount) — the trap is picking a resource-exhaustion answer when the event explicitly names a mount problem.

How to eliminate wrong answers

Option A is wrong because CPU exhaustion causes pods to remain in Pending (scheduler cannot place them) or triggers eviction/OOMKilled at runtime — it does not produce a FailedMount event. Option B is wrong because a container crash manifests as CrashLoopBackOff or Error status after the container has started, not as a mount failure during ContainerCreating. Option C is wrong because a large image causes slow image pulls (ImagePullBackOff or long ContainerCreating delays) but does not generate a FailedMount event tied to volume attachment.

Full explanation →

284

MCQeasy

You need to export Azure Monitor metric and log data to an external SIEM solution for security auditing. Which Azure feature should you use to stream this telemetry in real-time to an external Event Hub?

A.Azure Backup vault scheduled jobs

B.Azure Advisor recommendations export

C.Diagnostic settings configured to stream to an Azure Event Hub

D.Azure Resource Graph queries

AnswerC

Diagnostic settings stream platform metrics and resource logs to an Event Hub, which the external SIEM consumes in near real-time. This satisfies the stem's constraint: exporting Azure Monitor telemetry to an external SIEM via Event Hub.

Why this answer

Diagnostic settings in Azure Monitor are the mechanism that routes platform metrics and resource logs to supported sinks, including Azure Event Hubs, Log Analytics workspaces, and Storage accounts. Configuring a diagnostic setting with Event Hub as the destination streams telemetry in near real-time, which an external SIEM can consume via its Event Hub connector. This is the native, supported path for exporting Azure telemetry to third-party security platforms.

Exam trap

AI-200 often tests the misconception that Resource Graph or Advisor can export telemetry, when the only supported real-time streaming mechanism is a diagnostic setting pointed at an Event Hub.

How to eliminate wrong answers

Option A is wrong because Azure Backup vault scheduled jobs handle data protection and recovery, not telemetry streaming, and they have no Event Hub export capability. Option B is wrong because Azure Advisor recommendations export produces best-practice guidance, not metric or log telemetry, and cannot stream to Event Hubs. Option D is wrong because Azure Resource Graph queries return resource configuration and inventory data on demand; they are not a real-time telemetry pipeline and do not forward logs or metrics to Event Hubs.

Full explanation →

285

Multi-Selecteasy

Which TWO of the following are valid ways to authenticate an AKS cluster to an Azure Container Registry?

Select 2 answers

A.Azure Managed Identity.

B.Azure Active Directory Service Principal.

C.Azure Monitor.

D.Hardcoded Docker config file.

E.Azure Policy.

AnswersA, B

Azure Managed Identity lets the AKS cluster's kubelet identity authenticate to Azure Container Registry without storing credentials, satisfying the stem's requirement for a valid authentication method. The acrPull role assignment on the managed identity grants image pull permissions, eliminating secret rotation overhead.

Why this answer

Option A (Azure Managed Identity) is correct because AKS can use a system-assigned or user-assigned managed identity to authenticate to ACR via the AcrPull role assignment, eliminating stored credentials; the kubelet identity is granted the AcrPull role on the registry. Option B (Azure Active Directory Service Principal) is correct because you can create an AAD service principal, assign it the AcrPull role on the ACR, and store its appId/password as a Kubernetes imagePullSecret referenced by the pod spec. Option C (Azure Monitor) is incorrect because it is a monitoring/observability service, not an authentication mechanism for pulling images.

Option D (Hardcoded Docker config file) is incorrect because embedding credentials in a plaintext docker config.json is insecure and not a supported AKS-to-ACR authentication method. Option E (Azure Policy) is incorrect because it enforces governance/compliance rules, not registry authentication.

Exam trap

AI-200 often tests the distinction between authentication mechanisms and monitoring/governance services, tricking candidates into selecting Azure Monitor or Azure Policy because they sound like they 'control' access.

Full explanation →

286

MCQmedium

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

A.Use Azure Service Bus topics with session IDs set to the image hash.

B.Configure an Azure Storage queue that triggers whenever a blob is modified.

C.Poll the Azure Blob Storage container metadata every 5 seconds from the client app.

D.The AI worker publishes a custom event to an Azure Event Grid Topic upon completion.

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

287

MCQmedium

Your enterprise AI solution runs across multiple subscriptions. You want to implement centralized cost allocation tags for all Azure AI resources to ensure every resource is tagged with 'CostCenter' and 'Environment'. Which Azure feature should you use to automatically audit and enforce these tags?

A.Application Insights telemetry initializers

B.Azure Advisor security rules

C.Azure Policy with tag governance rules (e.g., 'Inherit a tag from the resource group' or 'Require specified tag')

D.Azure Cost Management budgets

AnswerC

Azure Policy tag governance rules audit and enforce tags across subscriptions, with built-in definitions such as 'Require a tag' and 'Inherit a tag from the resource group'. This centrally guarantees every Azure AI resource carries CostCenter and Environment, matching the stem's enforcement requirement.

Why this answer

Azure Policy is the governance service that audits and enforces resource properties, including tags, across subscriptions. Built-in tag policies such as 'Require a tag and its value on resources' and 'Inherit a tag from the resource group' let you deny non-compliant deployments or auto-remediate missing tags, and policy assignments can target management groups so they cover every subscription in the enterprise. This is the only option that provides automatic audit plus enforcement.

Exam trap

AI-200 often tests whether candidates confuse cost visibility tools (Cost Management budgets, Advisor) with enforcement tools (Azure Policy), luring them toward options that report on tags rather than audit and enforce them.

How to eliminate wrong answers

Option A is wrong because Application Insights telemetry initializers modify telemetry payloads (adding custom properties to traces), not resource tags, and they operate at the application SDK level. Option B is wrong because Azure Advisor provides recommendations on cost, security, reliability, and performance — it does not enforce or audit tags. Option D is wrong because Cost Management budgets trigger alerts or actions when spending thresholds are crossed; they consume tags for cost allocation but do not enforce their presence.

Full explanation →

288

Multi-Selectmedium

When configuring an Azure AI Search vectorizer for integrated vectorization, which TWO parameters or connections must be specified to link to an Azure OpenAI deployment? (Choose two)

Select 2 answers

A.Model name (e.g., text-embedding-ada-002)

B.SQL Server connection string

C.Cosmos DB container database name

D.Blob storage SAS token expiration time

E.Resource URL and authentication credentials (or managed identity)

AnswersA, E

The vectorizer must know which embedding model to invoke, so the deployment's model name is supplied in the vectorizer definition; Azure AI Search sends the query text to that model to generate the search vector.

Why this answer

Option A is correct because an Azure AI Search vectorizer that targets Azure OpenAI must specify the embedding model name (for example, text-embedding-ada-002 or text-embedding-3-large) so the service knows which deployed model to invoke for generating vectors. Option E is correct because the vectorizer also requires the Azure OpenAI resource endpoint URL plus authentication details — either an API key or a managed identity — to authorize calls to that deployment. Options B, C, and D are incorrect because SQL Server connection strings, Cosmos DB container database names, and Blob storage SAS token expiration times are unrelated to linking a vectorizer to an Azure OpenAI embedding deployment; they pertain to other data sources or storage access scenarios.

Exam trap

AI-200 often tests the confusion between data source connection details (SQL, Cosmos, Blob) and vectorizer configuration, which only needs the model name and the OpenAI endpoint plus credentials.

Full explanation →

289

Multi-Selecthard

You are analyzing security and compliance logs in an Azure Log Analytics workspace. You want to write KQL queries to investigate potential security incidents or token acquisition failures. Which THREE of the following KQL tables or operators are valid and useful for this investigation? (Choose three)

Select 3 answers

A.The exceptions table to analyze application error stack traces and failure types.

B.The SELECT * FROM command syntax traditionally used in relational SQL databases.

C.The DROP TABLE administrative command inside Application Insights log streams.

D.The summarize operator to aggregate telemetry data using functions like count() or percentile().

E.The dependencies table to inspect outbound API call targets, durations, and success results.

AnswersA, D, E

The exceptions table captures server-side and client-side exception telemetry, including stack traces, exception types and failure messages, which directly supports diagnosing token acquisition failures recorded by Microsoft Entra ID authentication libraries. It satisfies the stem's requirement for investigating token acquisition failures alongside security incidents within the same Log Analytics workspace.

Why this answer

Option A is correct because the exceptions table in Application Insights / Log Analytics stores exception telemetry including type, message, and stack traces, which is exactly what you need to diagnose application errors and token acquisition failures. Option D is correct because summarize is a core KQL operator that groups rows by one or more columns and applies aggregations such as count(), avg(), or percentile(), making it essential for spotting spikes or patterns in security and compliance telemetry. Option E is correct because the dependencies table records outbound calls (HTTP, SQL, Azure service calls) with target, duration, and success/failure result, which helps trace failed token or API calls.

Option B is not valid because KQL does not use SQL's SELECT * FROM syntax; queries start with a table name followed by pipe operators. Option C is not valid because DROP TABLE is a database DDL command and is not supported inside Application Insights or Log Analytics KQL queries.

Exam trap

AI-200 often tests whether candidates mistakenly apply relational SQL syntax (SELECT, DROP TABLE) to KQL, confusing the two query languages and assuming DDL operations are available in Log Analytics.

Full explanation →

290

MCQeasy

Which similarity metric measures the cosine of the angle between two vectors, focusing on orientation rather than magnitude, and is commonly used in Azure AI Search?

A.cosine

B.manhattan

C.euclidean

D.dotProduct

AnswerA

Cosine similarity computes the cosine of the angle between two vectors, measuring directional orientation and ignoring magnitude. This makes it suited to Azure AI Search vector queries, where document and query embeddings are compared by semantic direction rather than vector length.

Why this answer

Cosine similarity measures the cosine of the angle between two vectors, which captures their orientation (direction) while ignoring their magnitude. This makes it ideal for comparing text embeddings of different lengths, and it is the default and most commonly used similarity metric in Azure AI Search vector profiles. The option 'cosine' directly names this metric.

Exam trap

AI-200 often tests the confusion between cosine and dotProduct — candidates must remember that cosine explicitly normalizes by magnitude, while dotProduct does not, even though the two are mathematically related.

How to eliminate wrong answers

Option B is wrong because Manhattan (L1) distance sums the absolute differences of vector components — it measures magnitude-sensitive distance, not angular orientation. Option C is wrong because Euclidean (L2) distance measures straight-line distance between points, which is affected by vector magnitude and is not orientation-focused. Option D is wrong because dotProduct computes the sum of element-wise products; while related to cosine (cosine = dotProduct / (||a||·||b||)), it is a distinct metric that is sensitive to magnitude and is not the one described as measuring the cosine of the angle.

Full explanation →

291

MCQmedium

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

A.Enable Duplicate Detection with a history window of 5 attempts.

B.Configure the Max Delivery Count property on the queue and enable dead-lettering on message expiration or failure.

C.Set the AutoDeleteOnIdle property on the queue to 5 minutes.

D.Implement Event Grid dead-lettering pointing to an Azure Blob Storage container.

AnswerB

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

292

MCQeasy

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

A.Event Grid provides at-least-once delivery, so the partner should make their endpoint idempotent using the event ID.

B.Event Grid provides exactly-once delivery only when the subscriber returns HTTP 200, so duplicates mean the endpoint is returning errors.

C.Event Grid provides at-most-once delivery, so missing events are expected and duplicates are impossible.

D.Event Grid guarantees exactly-once delivery, so any duplicates indicate a misconfigured subscription filter.

AnswerA

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

Why this answer

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

Exam trap

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

Full explanation →

293

MCQmedium

You are building an AI search solution using Azure AI Search. You want to ensure that users searching for acronyms or synonyms receive relevant results even if the exact keyword does not appear in the document. Which feature should you configure?

A.Synonym maps

B.Scoring profiles

C.Semantic ranker

D.Vector profiles

AnswerA

Synonym maps expand a query term to equivalent terms at query time, so acronyms and synonyms match documents lacking the exact keyword. They are defined per index and applied to searchable fields, directly delivering the recall improvement described.

Why this answer

Synonym maps in Azure AI Search let you define equivalence rules so that a query term expands to its synonyms or acronym expansions at query time. This ensures documents containing the full term are returned even when the user searches with an acronym, and vice versa. Synonym maps are applied per-field and are the correct feature for handling acronyms and synonyms.

Exam trap

AI-200 often tests the confusion between query-time lexical features (synonym maps) and ranking features (scoring profiles, semantic ranker), luring candidates toward semantic ranker when the requirement is term expansion.

How to eliminate wrong answers

Option B is wrong because scoring profiles adjust the ranking of already-matched documents based on field weights or functions; they do not expand the query to match terms that are absent from the document. Option C is wrong because the semantic ranker re-ranks results using language understanding but does not perform synonym expansion for terms not present in the index. Option D is wrong because vector profiles configure HNSW parameters for vector fields and have nothing to do with lexical synonym matching.

Full explanation →

294

Multi-Selectmedium

You are designing a secure enterprise AI architecture on Azure. Which TWO of the following practices should you implement to secure credentials and service access? (Choose two)

Select 2 answers

A.Use system-assigned or user-assigned managed identities for Azure service-to-service authentication.

B.Store API keys and connection strings as plain text in Git repository configuration files.

C.Store runtime secrets and certificates in Azure Key Vault.

D.Grant subscription Owner permissions to all mobile client applications.

E.Disable TLS encryption on internal microservice communication to improve network throughput.

AnswersA, C

Managed identities let Azure services authenticate to other resources without storing credentials in code or configuration. Microsoft Entra ID issues and rotates the tokens automatically, eliminating secrets that could leak, which directly satisfies the requirement to secure service-to-service access.

Why this answer

Option A is correct because managed identities (system-assigned or user-assigned) let Azure services authenticate to resources such as Key Vault, Storage, and Azure OpenAI without embedding any credentials in code or configuration, eliminating secret sprawl and enabling Azure AD token-based access. Option C is correct because Azure Key Vault is the dedicated service for storing and controlling access to runtime secrets, API keys, connection strings, and certificates, with RBAC, access policies, soft-delete, purge protection, and auditing. Option B is wrong because committing API keys and connection strings as plain text in Git exposes them to anyone with repository access and to history scraping, violating secret-management best practices.

Option D is wrong because granting subscription Owner to mobile client applications violates least privilege and would let a compromised app modify or delete any resource in the subscription. Option E is wrong because disabling TLS on internal microservice traffic removes encryption in transit, enabling eavesdropping and man-in-the-middle attacks for a negligible throughput gain.

Full explanation →

295

MCQhard

Your enterprise AI solution runs on Azure Kubernetes Service (AKS) and utilizes Azure Key Vault to store secrets and API keys for cognitive services. You need to provide pods with secure, credential-less access to Azure Key Vault without storing connection strings in Kubernetes secrets or environment variables. Which integration should you implement?

A.Kubernetes Service Account tokens mapped to Key Vault access policies via static connection strings

B.A Kubernetes CronJob that pulls keys from Key Vault and creates sealed secrets

C.Azure Container Instances virtual nodes with managed system-assigned identities

D.Azure Key Vault Provider for Secrets Store CSI Driver with Azure AD Workload Identity

AnswerD

The Secrets Store CSI Driver mounts Key Vault secrets directly into pods as volumes, while Azure AD Workload Identity federates the pod's Kubernetes service account with Microsoft Entra ID, issuing short-lived tokens. This eliminates stored connection strings or environment variables, satisfying the credential-less access constraint.

Why this answer

The Azure Key Vault Provider for Secrets Store CSI Driver mounts Key Vault secrets directly into pods as volumes, and when combined with Azure AD Workload Identity, the pod authenticates to Key Vault using a federated Kubernetes service account token — no stored credentials, connection strings, or environment variables. This is the recommended credential-less pattern for AKS.

Exam trap

AI-200 often tests whether candidates recognize that credential-less access requires workload identity plus the Secrets Store CSI Driver, luring them toward sealed secrets or static connection strings that still store credentials.

How to eliminate wrong answers

Option A is wrong because static connection strings are exactly what the requirement forbids, and mapping service account tokens to access policies via connection strings is not a supported credential-less pattern. Option B is wrong because a CronJob that pulls keys and creates sealed secrets still materializes secrets in the cluster and requires the CronJob itself to hold credentials, defeating the credential-less goal. Option C is wrong because Azure Container Instances virtual nodes are a burst-scaling mechanism for AKS, not an identity or secret-access integration, and system-assigned identities on ACI do not solve pod-level Key Vault access.

Full explanation →

296

Multi-Selecthard

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

Select 3 answers

A.Azure Service Bus for managing financial transactions requiring strict ordering, sessions, and dead-lettering.

B.Azure Event Hubs for ingesting 500,000 telemetry events per second from smart grid sensors.

C.Azure Event Grid for routing blob-created notifications to serverless AI functions.

D.Azure Event Hubs for triggering real-time serverless webhooks upon user profile updates.

E.Azure Event Grid for streaming continuous IoT sensor telemetry into Azure Databricks.

AnswersA, B, C

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

Why this answer

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

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

Exam trap

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

Full explanation →

297

Multi-Selecteasy

You are auditing your Azure subscription for security best practices related to Azure AI resources. Which TWO of the following actions help enforce governance and security? (Choose two)

Select 2 answers

A.Grant every user Contributor rights to the entire Azure subscription.

B.Use Azure Policy to enforce allowed deployment regions and mandatory tagging.

C.Share the master subscription co-administrator password with all external contractors.

D.Disable all firewall rules on Azure Key Vault.

E.Apply 'CanNotDelete' resource locks on critical production AI resources.

AnswersB, E

Azure Policy evaluates resource properties during deployment and flags non-compliant resources, directly enforcing the governance constraints in the stem: restricting deployments to approved regions and requiring mandatory tags. This satisfies the subscription-wide audit requirement, unlike identity or network controls that address different security axes.

Why this answer

Applying resource locks prevents accidental deletion, and enforcing Azure Policy ensures regional and configuration compliance.

Full explanation →

298

MCQhard

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

A.All queued messages are automatically migrated to the secondary region within 5 seconds.

B.Azure Event Grid automatically replays all lost messages from the storage capture.

C.The primary namespace messages are permanently deleted and cannot be recovered.

D.Messages remaining in the primary namespace are not automatically replicated to the secondary namespace; failover relies on metadata synchronization.

AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →

299

Multi-Selectmedium

Which TWO of the following features help manage traffic to containerized applications?

Select 2 answers

A.Azure Monitor.

B.Azure Key Vault.

C.Service Mesh (Istio/Linkerd).

D.Azure Blob Storage.

E.Kubernetes Ingress Controller.

AnswersC, E

A service mesh such as Istio or Linkerd injects sidecar proxies alongside each pod, giving layer-7 traffic management: dynamic routing, retries, timeouts, mutual TLS and observability between services. This satisfies the requirement to manage east-west traffic between containerised applications independently of application code.

Why this answer

A Service Mesh such as Istio or Linkerd (option C) is correct because it provides layer-7 traffic management for containerized workloads, including intelligent routing, load balancing, traffic splitting for canary/blue-green deployments, retries, timeouts, and mutual TLS between pods via sidecar proxies. A Kubernetes Ingress Controller (option E) is correct because it exposes HTTP/HTTPS routes from outside the cluster to Services inside the cluster, performing host- and path-based routing, TLS termination, and load balancing to containerized applications. Azure Monitor (option A) is an observability platform for metrics, logs, and alerts, not a traffic-routing mechanism.

Azure Key Vault (option B) is a secrets, keys, and certificate management service, unrelated to directing application traffic. Azure Blob Storage (option D) is object storage for unstructured data and does not manage or route network traffic to containers.

Exam trap

AI-200 often tests the confusion between observability tools (Azure Monitor) and traffic management tools (Ingress, service mesh) — candidates pick Azure Monitor because it 'manages' something, but it does not route traffic.

Full explanation →

300

Multi-Selecthard

Which TWO of the following techniques help optimize the performance of containerized AI models in AKS?

Select 2 answers

A.Tune pod resource limits and requests.

B.Disable all logging.

C.Use the standard CNI instead of Azure CNI.

D.Increase the replica count to 100 for all services.

E.Use dedicated node pools for GPU tasks.

AnswersA, E

Tuning pod resource requests and limits directly addresses the CPU and memory constraints that throttle containerised inference in AKS. Accurate requests let the scheduler place pods on nodes with sufficient capacity, while limits prevent noisy-neighbour contention, sustaining the throughput and latency the stem's performance objective demands.

Why this answer

Option A is correct because setting accurate CPU and memory requests lets the AKS scheduler place pods on nodes with sufficient capacity, while proper limits prevent noisy-neighbor contention and OOMKills, directly improving the stability and throughput of containerized AI inference or training workloads. Option E is correct because dedicating node pools with GPU-enabled VM SKUs (e.g., NC/ND series) to GPU tasks ensures AI pods get exclusive access to GPU resources, avoids scheduling conflicts with CPU-only workloads, and allows independent scaling and taints/tolerations for GPU nodes. Option B is wrong because disabling all logging removes observability needed to diagnose performance bottlenecks and does not improve runtime performance.

Option C is wrong because switching from Azure CNI to standard (kubenet) CNI does not optimize AI model performance and can reduce networking capabilities. Option D is wrong because blindly increasing replicas to 100 for all services wastes resources, can cause scheduling pressure and cost blowups, and does not address per-pod performance.

Exam trap

AI-200 often tests the misconception that 'more replicas always means better performance' or that networking/logging changes are performance optimizations, when the real levers are resource tuning and workload isolation via dedicated node pools.

Full explanation →

Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) (AI-200) — Questions 226–300