Courseiva

Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) (AI-200) — Questions 76–150

418 questions total · 6 pages · All types, answers revealed

Take a mock examExam hub
Page 1

Page 2 of 6

Page 3
76
MCQmedium

You have a large image that takes a long time to pull. You want to speed up deployment in AKS. Which feature should you enable?

A.Use a public mirror for the image.
B.Increase the AKS node count.
C.Use smaller base images.
D.Enable Artifact Streaming in ACR.
AnswerD

Artifact Streaming in Azure Container Registry lets AKS pull only the image layers needed to start the container, rather than downloading the whole image first. This reduces startup latency for large images, directly addressing the slow pull.

Why this answer

Artifact Streaming in ACR (also called streaming artifacts) allows AKS nodes to start containers before the entire image is downloaded, by streaming only the layers needed at startup. This dramatically reduces cold-start time for large images because the kubelet doesn't wait for a full pull. It's the purpose-built ACR feature for accelerating large-image deployments in AKS.

Exam trap

AI-200 often tests the difference between build-time image optimizations (smaller base images, multi-stage builds) and registry/deployment-time acceleration features like Artifact Streaming — candidates pick 'smaller base images' because it sounds like the obvious fix, but the question asks what to enable for an already-large image.

How to eliminate wrong answers

Option A is wrong because a public mirror only changes the registry location — it doesn't change the fact that the full image must still be pulled, and it may introduce security/compliance issues. Option B is wrong because adding nodes increases capacity/parallelism but does not reduce the time to pull a single large image onto a node. Option C is wrong because using smaller base images is a build-time optimization, not a deployment-time feature you 'enable' on an existing large image.

Full explanation →
77
MCQeasy

Which Azure service provides a fully managed NoSQL database with native vector search capabilities and turnkey multi-region replication?

A.Azure Table Storage
B.Azure Blob Storage
C.Azure Cosmos DB
D.Azure SQL Database
AnswerC

Azure Cosmos DB is a fully managed NoSQL database offering native vector search and turnkey multi-region replication, so it satisfies both constraints in the stem without additional infrastructure. Its vector indexing integrates directly with the core database engine rather than requiring a separate search service.

Why this answer

Azure Cosmos DB is Microsoft's globally distributed, multi-model NoSQL database service that natively supports vector search through its integrated vector indexing and querying capabilities. It offers turnkey multi-region replication with configurable consistency levels and single-digit millisecond latency at the 99th percentile. The native vector search feature allows storing and querying high-dimensional embeddings directly alongside JSON documents without a separate vector store.

Exam trap

AI-200 often tests the distinction between services that merely store data (Blob, Table) and those that provide a queryable database engine with native vector indexing, so candidates confuse 'storage' with 'database with vector search'.

How to eliminate wrong answers

Option A is wrong because Azure Table Storage is a simple key-attribute NoSQL store that lacks vector search capabilities and only supports basic single-region or manually configured geo-redundant storage without turnkey multi-region writes. Option B is wrong because Azure Blob Storage is object storage for unstructured data and does not provide a queryable NoSQL database engine or native vector search. Option D is wrong because Azure SQL Database is a relational database that supports vector data types via preview features but is not a NoSQL service and does not offer turnkey multi-region write replication.

Full explanation →
78
MCQhard

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

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

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

Why this answer

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

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

Exam trap

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

Full explanation →
79
Multi-Selectmedium

Which TWO mechanisms can be used to monitor and optimize costs associated with Azure AI services?

Select 2 answers
A.Network Watcher IP flow logs.
B.Application Insights live metrics stream.
C.Azure Bastion session monitoring logs.
D.Azure Budgets with configured email alert notifications.
E.Azure Advisor cost recommendations for right-sizing and idle resource cleanup.
AnswersD, E

Azure Budgets track actual and forecast spend against a defined threshold and trigger email alert notifications when usage approaches or exceeds it. This satisfies the requirement to monitor and optimise costs for Azure AI services through proactive notification.

Why this answer

Azure Budgets (option D) let you set spending thresholds on a scope such as a resource group or subscription and trigger email alert notifications when actual or forecasted costs approach or exceed the budget, which directly supports monitoring and controlling Azure AI service spend. Azure Advisor cost recommendations (option E) analyze usage telemetry to surface right-sizing guidance and idle or underutilized resource cleanup, which is exactly the optimization mechanism for reducing AI service costs. The remaining options are unrelated to cost management: Network Watcher IP flow logs (A) capture network traffic metadata for connectivity and security troubleshooting, Application Insights live metrics stream (B) provides real-time performance and telemetry diagnostics for applications, and Azure Bastion session monitoring logs (C) record secure RDP/SSH session activity through Bastion hosts, none of which report or optimize billing costs.

Exam trap

AI-200 often tests the boundary between cost management tools (Budgets, Advisor) and operational monitoring tools (Application Insights, Network Watcher) — candidates pick performance or security tools thinking they provide cost visibility, when only Budgets and Advisor address cost.

Full explanation →
80
Multi-Selectmedium

Which THREE configuration steps are required when setting up a Private Endpoint for an Azure OpenAI resource?

Select 3 answers
A.Enable public network access on the Azure OpenAI resource with unrestricted IP ranges.
B.Deploy the private endpoint into a subnet within your Virtual Network.
C.Integrate with a private DNS zone to resolve the Azure OpenAI FQDN to the private IP address.
D.Assign a public IP address directly to the private endpoint network interface.
E.Select the target sub-resource, such as 'account', for the Azure OpenAI service.
AnswersB, C, E

A private endpoint is a network interface, so it must be deployed into a subnet within your Virtual Network. This placement gives the Azure OpenAI resource a private IP reachable only inside that VNet, satisfying the isolation requirement.

Why this answer

Option B is correct because a private endpoint is a network interface created inside a subnet of your Virtual Network, so the endpoint must be deployed into a VNet subnet to give the Azure OpenAI resource a private IP address reachable from that network. Option C is correct because name resolution must map the Azure OpenAI FQDN (for example, <resource>.openai.azure.com) to the private endpoint's private IP; this is done by integrating with a private DNS zone such as privatelink.openai.azure.com and linking it to the VNet. Option E is correct because when creating the private endpoint you must specify the target sub-resource (group ID) of the Azure OpenAI service, which is 'account', so the endpoint connects to the correct service component.

Option A is not required and is in fact contrary to the goal, since private endpoint access typically involves disabling or restricting public network access rather than enabling it with unrestricted IP ranges. Option D is incorrect because a private endpoint's network interface receives a private IP address from the subnet; it is not assigned a public IP address.

Exam trap

AI-200 often tests the misconception that a Private Endpoint requires enabling public access or assigning a public IP, when in fact it is the opposite — private endpoints use private IPs and typically accompany disabling public network access.

Full explanation →
81
Multi-Selectmedium

Which THREE of the following are security best practices for container registries?

Select 3 answers
A.Use Private Link for network access.
B.Disable HTTPS for faster access.
C.Apply Role-Based Access Control (RBAC).
D.Use the 'latest' tag for production images.
E.Enable vulnerability scanning.
AnswersA, C, E

Private Link gives the registry a private endpoint on your virtual network, so image pulls and pushes never traverse the public internet. This satisfies the stem's network-isolation constraint by removing public exposure of the registry endpoint, blocking anonymous or internet-originated access attempts.

Why this answer

Option A is correct because using Azure Private Link (or an equivalent private endpoint) for registry access keeps traffic on the Microsoft backbone network and eliminates exposure of the registry to the public internet, preventing unauthorized access and data exfiltration. Option C is correct because applying Role-Based Access Control (RBAC) enforces least-privilege access, ensuring only authorized identities can push, pull, or manage registry resources such as repositories and images. Option E is correct because enabling vulnerability scanning (for example, Microsoft Defender for Containers or registry-integrated scanning) automatically detects known CVEs in image layers and base images, allowing remediation before deployment.

Option B is not a best practice because disabling HTTPS exposes registry credentials and image layers to man-in-the-middle attacks and tampering; registries must enforce TLS. Option D is not a best practice because the 'latest' tag is mutable and non-deterministic, so production deployments should use immutable, version-specific tags or digests to guarantee reproducibility and traceability.

Exam trap

AI-200 often tests whether candidates confuse convenience shortcuts (disabling HTTPS, using 'latest') with actual security controls, so any option that weakens transport security or reproducibility is always wrong.

Full explanation →
82
MCQmedium

You are deploying a containerized machine learning inference service to Azure Container Apps. The model artifact is large (15 GB) and must be securely loaded during container startup. What is the most efficient way to mount this model data into the container app?

A.Mount an Azure Files volume to the container app
B.Download the model over the public internet at container boot
C.Bake the model directly into the Docker image layer
D.Store the model in environment variables
AnswerA

Azure Files volumes mount directly into the container filesystem over SMB, so the 15 GB artifact is read at startup without being baked into the image or copied through a build step. This satisfies the stem's requirement for secure, efficient loading of large model data.

Why this answer

Mounting an Azure Files volume to the Container App is the most efficient approach because the 15 GB model is stored once in a durable share and mounted at container startup without bloating the image or re-downloading over the internet. Azure Files is the native persistent volume type for Container Apps and supports secure access via storage account keys or managed identity, satisfying the 'securely loaded' requirement.

Exam trap

AI-200 often tests whether candidates choose image-baking or internet downloads for large models — the exam expects you to recognize that persistent volume mounts (Azure Files) are the efficient, secure pattern.

How to eliminate wrong answers

Option B is wrong because downloading a 15 GB model over the public internet at every container boot is slow, unreliable, and exposes the artifact to network egress costs and potential tampering. Option C is wrong because baking a 15 GB model into the Docker image layer creates a massive image, slows every pull, wastes registry storage, and makes model updates require a full image rebuild and redeploy. Option D is wrong because environment variables are limited in size (typically a few KB) and are meant for configuration, not multi-gigabyte binary artifacts.

Full explanation →
83
Multi-Selectmedium

Your organization requires strict network isolation for all Azure AI services. Which TWO of the following networking features should you configure to prevent public internet exposure? (Choose two)

Select 2 answers
A.Azure Private Link with private endpoints mapped to your virtual network
B.Enabling anonymous access on Application Insights data ingestion endpoints
C.Disabling public network access on the Azure AI resource firewall settings
D.Using Azure Front Door with global public anycast IPs
E.Assigning public IP addresses to all backend scoring containers
AnswersA, C

Private endpoints assign a private IP from your virtual network subnet to the Azure AI service, so traffic traverses the Microsoft backbone rather than the public internet. This directly satisfies the strict network isolation requirement by removing public exposure entirely.

Why this answer

Private endpoints via Azure Private Link and disabling public network access on PaaS resources ensure complete network isolation from the public internet.

Full explanation →
84
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
85
Multi-Selecthard

You are configuring an Azure Kubernetes Service (AKS) cluster for enterprise AI workloads. Which THREE practices should you implement to enhance cluster security and isolation? (Choose three.)

Select 3 answers
A.Configure Microsoft Entra Workload Identity for pod-to-Azure service authentication
B.Disable TLS on the API server to improve inter-node communication speed
C.Share a single service principal across all namespaces for simplified administration
D.Enable Azure Policy for Kubernetes for governance and compliance enforcement
E.Integrate Microsoft Entra ID with Azure RBAC for Kubernetes authorization
AnswersA, D, E

Workload Identity federates a Kubernetes service account with a Microsoft Entra ID identity via OIDC, so pods obtain short-lived tokens instead of stored secrets. This removes long-lived credentials from the cluster, directly satisfying the isolation requirement for pod-to-Azure service authentication.

Why this answer

Option A is correct because Microsoft Entra Workload Identity federates Kubernetes service accounts with Microsoft Entra ID via OIDC, letting pods authenticate to Azure services (Key Vault, Storage, etc.) without storing secrets or using a shared service principal. Option D is correct because Azure Policy for Kubernetes (via the Gatekeeper admission controller) enforces governance and compliance at the cluster level, such as restricting privileged containers, hostPath mounts, and allowed registries. Option E is correct because integrating Microsoft Entra ID with Azure RBAC for Kubernetes authorization enables centralized, identity-based access control to the API server, replacing static local accounts and supporting least-privilege role assignments.

Option B is incorrect because disabling TLS on the API server exposes credentials and traffic to interception and violates security best practices; performance gains do not justify it. Option C is incorrect because sharing a single service principal across all namespaces eliminates isolation, creates a single credential to compromise, and prevents per-workload least-privilege scoping.

Exam trap

The trap is accepting 'simplified administration' or 'performance' justifications for insecure choices; the exam rewards least-privilege identity, policy enforcement, and centralized RBAC over convenience.

Full explanation →
86
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
87
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
88
MCQhard

Your team is running an AI copilot application that uses Azure OpenAI. To comply with data residency regulations, you need to verify that prompts and completions are processed entirely within a specific Azure region and that no data is persisted outside that region. Where can you verify regional data processing and residency commitments?

A.Azure OpenAI service compliance terms and data residency documentation in the Azure Trust Center
B.Azure Resource Graph queries filtering by region
C.Azure Monitor geographic latency metrics dashboard
D.Application Insights dependency maps
AnswerA

The Azure Trust Center publishes Azure OpenAI compliance terms and data residency commitments, documenting which regions process prompts and completions and confirming no persistence outside them. This satisfies the requirement to verify regional processing against regulatory obligations.

Why this answer

The Azure Trust Center hosts Azure OpenAI Service compliance terms and data residency documentation, which is where you verify regional processing and residency commitments. It documents where data is processed, whether prompts/completions are stored, and the contractual commitments Microsoft makes. This is the authoritative source for compliance and data residency verification.

Exam trap

AI-200 often tests the confusion between resource metadata tools (Resource Graph) and compliance documentation (Trust Center), tempting candidates to pick a technical query tool when the question asks where to verify contractual residency commitments.

How to eliminate wrong answers

Option B is wrong because Azure Resource Graph queries return resource metadata (locations, tags, properties) but do not document or verify data processing/residency commitments; they show where resources are deployed, not where data is processed or whether it is persisted. Option C is wrong because Azure Monitor geographic latency metrics measure performance/latency, not data residency or processing location, and have no bearing on compliance commitments. Option D is wrong because Application Insights dependency maps visualize application component dependencies and call flows, not data residency or compliance terms.

Full explanation →
89
Multi-Selecthard

You are designing an enterprise search architecture on Azure that requires hybrid search capabilities. Which THREE components or features must be configured to successfully execute a hybrid query with semantic ranking in Azure AI Search? (Choose three)

Select 3 answers
A.Azure Blob Storage configured as an external data source
B.A searchable Edm.String text field for keyword matching
C.A vector field defined with Edm.SingleCollection and a vector profile
D.An Azure Functions application for manual score merging
E.A semantic configuration defined on the index
AnswersB, C, E

Hybrid queries need a searchable Edm.String field so BM25 keyword matching can run alongside vector similarity. Without it, only the vector half executes, so the keyword leg of the hybrid query and its semantic reranking input are missing.

Why this answer

Option B is correct because hybrid search always includes a keyword (full-text) component, which requires at least one searchable Edm.String field in the index so the query can perform BM25-scored term matching via the inverted index. Option C is correct because the vector half of a hybrid query needs a vector field of type Collection(Edm.Single) (Edm.SingleCollection) plus an attached vector profile (with HNSW or exhaustive KNN algorithm and a vectorizer if integrated vectorization is used) so the query engine can run the approximate nearest neighbor search. Option E is correct because semantic ranking is not automatic — it requires a semanticConfiguration defined on the index (specifying title, content, and keyword priority fields) that is referenced in the query's semanticSearch settings to invoke the L2 semantic reranker.

Option A is not required: Azure Blob Storage is only an optional data source for indexers/pull-based ingestion, and hybrid queries can run against any populated index regardless of origin. Option D is not required: Azure AI Search natively performs reciprocal rank fusion (RRF) to merge keyword and vector scores internally, so no external Azure Functions score-merging logic is needed.

Exam trap

AI-200 often tests whether candidates confuse ingestion components (blob data sources, indexers) with query-time components (text field, vector field, semantic config) — only the latter are required to execute a hybrid semantic query.

Full explanation →
90
MCQmedium

You are integrating Azure OpenAI Service's text-embedding-ada-002 model with Azure AI Search. You want to automate the generation of embeddings directly inside the search service during data ingestion. Which component of Azure AI Search should you configure?

A.Semantic ranker configuration profile
B.Azure AI Search Indexer with integrated vectorization
C.Azure Function scheduled trigger for batch updates
D.Custom Web API skill in Azure AI Services enrichment pipeline
AnswerB

An indexer with integrated vectorization invokes the embedding model during ingestion, chunking and vectorising documents automatically. This satisfies the requirement to generate embeddings inside the search service, rather than pushing vectors from an external application.

Why this answer

Azure AI Search's indexer with integrated vectorization natively invokes an embedding model (such as Azure OpenAI's text-embedding-ada-002) during the enrichment pipeline, so vectors are generated and written to the index automatically at ingestion time. This removes the need for external code to pre-compute embeddings and push them into the index. Configuring the indexer's vectorizer and embedding skill is the supported, first-party mechanism for this automation.

Exam trap

AI-200 often tests whether candidates confuse query-time features (semantic ranker, vectorizers) with ingestion-time automation (indexers with integrated vectorization), causing them to pick the semantic ranker option.

How to eliminate wrong answers

Option A is wrong because the semantic ranker only re-orders an existing result set using deep-learning models at query time; it does not generate embeddings during ingestion. Option C is wrong because an Azure Function scheduled trigger is an external, custom orchestration approach that requires you to write and maintain code to call Azure OpenAI and push vectors, rather than using the search service's built-in automation. Option D is wrong because a Custom Web API skill calls an external endpoint for enrichment but is not the purpose-built integrated vectorization feature; it adds latency, cost, and custom code where the indexer's native vectorizer suffices.

Full explanation →
91
MCQeasy

You need to store private AI model weights in an Azure Container Registry (ACR). Which authentication method follows the principle of least privilege for an AKS cluster to pull these images?

A.Service Principal with Contributor role.
B.ACR Admin account credentials.
C.Azure Managed Identity.
D.A shared SAS token generated for the registry.
AnswerC

Azure Managed Identity issues token-based credentials scoped to the AKS cluster's identity, so no registry passwords or service principal secrets are stored. Granting that identity only the AcrPull role on the registry satisfies least privilege, unlike admin credentials or broad subscription-level roles.

Why this answer

Azure Managed Identity lets the AKS cluster authenticate to ACR without storing any credentials, and the identity can be granted only the AcrPull role scoped to the specific registry. This satisfies least privilege because the cluster gets exactly the permission needed (pull images) and nothing more, with no secrets to rotate or leak. It is the recommended, Microsoft-supported approach for AKS-to-ACR authentication.

Exam trap

AI-200 often tests the misconception that a Service Principal with Contributor or the ACR Admin account is 'fine' for image pulls — the exam expects you to recognize that only a scoped identity (Managed Identity with AcrPull) satisfies least privilege.

How to eliminate wrong answers

Option A is wrong because a Service Principal with the Contributor role grants broad management permissions across the subscription or resource group — far more than the pull-only access required, violating least privilege. Option B is wrong because the ACR Admin account is a shared, all-powerful credential that bypasses RBAC and cannot be scoped; it is explicitly discouraged for production. Option D is wrong because ACR does not issue SAS tokens for image pulls — SAS is an Azure Storage concept, and using it here reflects a fundamental misunderstanding of ACR authentication mechanisms.

Full explanation →
92
MCQeasy

You are storing vector embeddings generated by Azure OpenAI in Azure Cosmos DB for NoSQL. Which built-in SQL function must you use within your query to compute vector distance when executing a similarity search?

A.EmbeddingDistance()
B.GetVectorDistance()
C.VectorDistance()
D.CosineSimilarity()
AnswerC

VectorDistance() is the built-in Cosmos DB for NoSQL function that computes cosine, dot product or Euclidean distance between stored vectors and a query vector, satisfying the similarity-search requirement. No other native SQL function performs vector maths, so it is mandatory for ranking embeddings.

Why this answer

Azure Cosmos DB for NoSQL exposes the built-in VectorDistance() function, which computes the distance between a stored vector and a query vector using the configured distance function (cosine, dot product, or Euclidean). It is used in the ORDER BY clause of a query to return the nearest neighbors. This is the only correct built-in function name for vector similarity in Cosmos DB for NoSQL.

Exam trap

The trap here is that candidates recall generic vector terminology like 'cosine similarity' and pick CosineSimilarity(), not realizing Cosmos DB exposes a single VectorDistance() function whose metric is configured separately.

How to eliminate wrong answers

Option A is wrong because EmbeddingDistance() is not a Cosmos DB SQL function; it is a fabricated name that resembles other vector APIs. Option B is wrong because GetVectorDistance() does not exist in the Cosmos DB SQL grammar; the correct prefix is Vector, not GetVector. Option D is wrong because CosineSimilarity() is not a built-in Cosmos DB function — cosine is a distance metric selected in the vector policy, not a callable SQL function.

Full explanation →
93
Multi-Selecthard

Your enterprise AI solution runs on Azure Kubernetes Service (AKS) and connects to Azure OpenAI. You need to ensure comprehensive security across network, identity, and secrets. Which THREE of the following configurations should you deploy? (Choose three)

Select 3 answers
A.Azure AD Workload Identity for Kubernetes pods to securely access Azure OpenAI without static keys.
B.Kubernetes Network Policies to restrict pod-to-pod communication within the cluster.
C.Azure Key Vault Provider for Secrets Store CSI Driver for secure secret mounting.
D.Grant cluster-admin permissions to every unauthenticated container image.
E.Disable all TLS encryption on Kubernetes ingress controllers.
AnswersA, B, C

Azure AD Workload Identity federates Kubernetes service accounts with Microsoft Entra ID, letting pods obtain tokens for Azure OpenAI without stored secrets. This satisfies the stem's identity and secrets security requirement across the AKS solution.

Why this answer

Option A is correct because Azure AD Workload Identity federates a Kubernetes service account with an Azure AD identity via OIDC, letting pods obtain Azure AD tokens for Azure OpenAI through the token projection without embedding static API keys. Option B is correct because Kubernetes Network Policies enforce pod-level ingress/egress rules (via the cluster's CNI, e.g., Azure CNI with Calico or Cilium), segmenting pod-to-pod traffic and limiting lateral movement inside the AKS cluster. Option C is correct because the Azure Key Vault Provider for Secrets Store CSI Driver mounts Key Vault secrets, keys, and certificates into pods as volumes, keeping secrets out of etcd and manifests and enabling rotation and managed-identity-based access.

Option D is wrong because granting cluster-admin to unauthenticated container images is a severe privilege-escalation and unauthenticated-access risk, violating least privilege. Option E is wrong because disabling TLS on ingress controllers exposes traffic in plaintext, breaking confidentiality and integrity for inbound connections.

Full explanation →
94
MCQhard

You are building an AI search solution in Azure AI Search. You need to ensure that when documents are deleted from the primary database, they are also automatically removed from the search index without requiring manual API calls. How should you configure the indexer?

A.Write a custom Azure Function triggered by every delete event to issue an HTTP DELETE to the search index
B.Configure a soft-delete policy on the indexer referencing a deletion tracking column or flag in the data source
C.Re-create the entire search index from scratch daily
D.Set the index retention policy to auto-purge every 24 hours
AnswerB

A soft-delete policy detects deletions via a designated tracking column or flag in the source data, so the indexer removes corresponding documents from the index automatically during scheduled runs, satisfying the requirement for no manual API calls.

Why this answer

Configuring a soft-delete policy on the indexer referencing a deletion tracking column or flag in the data source allows Azure AI Search to automatically detect and remove documents from the index when they are deleted or marked as deleted in the source. This is the native, automated way to handle deletions without manual API calls.

Exam trap

AI-200 often tests the misconception that manual API calls or custom code are needed for deletions, when in fact soft-delete policies provide automated deletion detection; candidates may overlook this built-in feature.

How to eliminate wrong answers

Option A is wrong because writing a custom Azure Function is a manual, code-heavy approach that requires additional infrastructure and is not the built-in method; it also may not be reliable or scalable. Option C is wrong because re-creating the entire search index daily is inefficient, causes downtime, and does not specifically handle deletions. Option D is wrong because there is no index retention policy that auto-purges every 24 hours in Azure AI Search; this is not a feature.

Full explanation →
95
MCQeasy

You are building an AI container image and need to minimize its final size to speed up deployment times. Which multi-stage build practice should you follow?

A.Use a builder stage for compilation and copy only runtime artifacts into a slim base image
B.Store model weights directly inside the container image layers
C.Install all development tools and pip packages in a single RUN instruction
D.Disable container image compression when pushing to ACR
AnswerA

A multi-stage build compiles dependencies in a builder stage, then copies only the runtime artefacts into a slim base image, excluding compilers, caches and build tooling. This directly satisfies the stem's constraint of minimising final image size to accelerate deployment.

Why this answer

Multi-stage builds use a builder stage containing compilers, SDKs, and build dependencies, then copy only the compiled artifacts (binaries, wheels, model files needed at runtime) into a minimal runtime base image such as python:3.11-slim or alpine. This keeps the final image free of build toolchains, caches, and intermediate layers, dramatically reducing image size and pull time. The other options either bloat the image or are unrelated to build strategy.

Exam trap

AI-200 often tests whether candidates confuse 'fewer layers' (a Dockerfile optimization) with 'smaller final image' (which requires multi-stage builds to exclude build-time dependencies).

How to eliminate wrong answers

Option B is wrong because baking model weights into image layers inflates the image by gigabytes and prevents independent updates of models versus code. Option C is wrong because combining all installs into one RUN may reduce layer count but does not remove dev tools or pip caches, so the image stays large; multi-stage is what actually strips build-time dependencies. Option D is wrong because disabling compression increases the pushed artifact size and slows pulls — it does not reduce the image itself and hurts deployment speed.

Full explanation →
96
Multi-Selecthard

You are configuring rolling updates for an AI model inference service on AKS with zero downtime requirements. Which THREE deployment or pod configuration settings should you configure?

Select 3 answers
A.Deployment strategy set to RollingUpdate with configured maxSurge and maxUnavailable
B.Readiness and liveness probes to verify container health before traffic routing
C.Setting restart policy to Never on the Deployment template
D.Pod Disruption Budget (PDB) to ensure minimum available replicas during node drains
E.Disabling all container health checks to speed up pod termination
AnswersA, B, D

RollingUpdate with tuned maxSurge and maxUnavailable governs how many pods are added above desired count and how many may be unavailable during the rollout. Setting maxUnavailable to zero guarantees capacity never dips, satisfying the zero-downtime constraint.

Why this answer

Option A is correct because a Deployment with strategy RollingUpdate and tuned maxSurge/maxUnavailable parameters replaces pods incrementally, ensuring new replicas become available before old ones are terminated, which is essential for zero-downtime rollouts. Option B is correct because readiness probes gate Service endpoint membership so traffic only reaches containers that are actually ready, while liveness probes restart hung containers, both preventing failed pods from serving inference requests. Option D is correct because a Pod Disruption Budget enforces a minimum number of available replicas during voluntary disruptions such as node drains or upgrades, protecting capacity while nodes are cordoned.

Option C is incorrect because restartPolicy Never is only valid for standalone Pods, not for Deployment-managed pods (which require Always), and it would prevent automatic recovery. Option E is incorrect because disabling health checks removes the readiness gating that zero-downtime routing depends on and can send traffic to unready or broken containers.

Exam trap

AI-200 often tests whether candidates know that restartPolicy: Never is illegal on Deployments and that removing health checks is never a valid optimization — the exam baits speed-focused answers that actually break availability.

Full explanation →
97
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
98
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
99
Multi-Selecthard

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

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

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

Why this answer

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

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

Exam trap

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

Full explanation →
100
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
101
Multi-Selecthard

Your Azure AI application relies on Azure OpenAI and Azure AI Search. You need to troubleshoot a sudden surge in HTTP errors and latency. Which THREE of the following Azure Monitor / Application Insights features or tools should you use to diagnose the issue? (Choose three)

Select 3 answers
A.Azure Cost Management recommendation advisor for server resizing.
B.Application Map in Application Insights to identify downstream dependency latency bottlenecks.
C.Log Analytics workspace with KQL queries against the exceptions and dependencies tables.
D.Metrics explorer in Azure Monitor to check Azure OpenAI token limits and throttling metrics.
E.Azure Bastion diagnostic logs for RDP login failures.
AnswersB, C, D

Application Map renders the call topology between your app, Azure OpenAI and Azure AI Search, exposing which dependency contributes the latency. This satisfies the stem's need to pinpoint whether the surge originates in a downstream service rather than the front end.

Why this answer

Application Map visualizes dependencies and latency bottlenecks, Metrics explorer tracks token consumption and throttling counters, and Log Analytics enables KQL queries for specific exception traces.

Full explanation →
102
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
103
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
104
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
105
Multi-Selecthard

Which THREE of the following options are important when configuring an AKS cluster for AI workloads?

Select 3 answers
A.Network policies for pod communication isolation.
B.Always run every pod as privileged.
C.Managed identity for cluster components.
D.Disable all internal firewalls.
E.GPU-enabled node pools.
AnswersA, C, E

Network policies apply Kubernetes rules controlling which pods may exchange traffic, isolating workloads and limiting lateral movement between namespaces. This satisfies the stem's AI workload constraint, where multi-tenant training jobs and inference endpoints sharing a cluster need segmented pod communication.

Why this answer

Option A is correct because network policies (implemented via Azure Network Policy or Calico on AKS) let you isolate pod-to-pod traffic, which is essential for securing AI workloads that often handle sensitive data and expose inference endpoints. Option C is correct because managed identity lets AKS cluster components (such as the kubelet, control plane, and CSI drivers) authenticate to Azure resources like Key Vault, ACR, and Storage without embedding credentials, which is a security best practice for AI pipelines pulling models and data. Option E is correct because AI workloads such as model training and inference require GPU acceleration, and AKS supports GPU-enabled node pools (e.g., NC/ND-series VMs with NVIDIA device plugin) to schedule those workloads.

Option B is not appropriate because running every pod as privileged grants full host access and violates least-privilege, dramatically increasing the attack surface. Option D is wrong because disabling internal firewalls removes necessary network segmentation and security controls rather than properly configuring NSGs, Azure Firewall, or private endpoints.

Exam trap

AI-200 often tests the misconception that 'more privilege equals better performance' — candidates pick privileged pods or disabled firewalls thinking they remove bottlenecks, when the exam expects secure, least-privilege AI cluster design.

Full explanation →
106
MCQeasy

You are deploying an Azure OpenAI Service resource and need to ensure that API keys are not used for authentication. Which configuration should you apply?

A.Disable local authentication on the Azure OpenAI resource and grant users the Cognitive Services OpenAI User role.
B.Configure a managed identity on the app service and store the API key in Azure Key Vault.
C.Implement Cross-Origin Resource Sharing (CORS) rules on the Azure OpenAI resource.
D.Enable soft-delete on the Azure OpenAI resource.
AnswerA

Disabling local authentication removes API-key access entirely, forcing Microsoft Entra ID token-based authentication, while the Cognitive Services OpenAI User role grants the necessary data-plane permissions. Together these satisfy the requirement that API keys are not used for authentication.

Why this answer

Azure role-based access control (Azure RBAC) can be used to authenticate requests to Azure OpenAI by disabling local authentication (API keys) via the 'disableLocalAuth' property.

Full explanation →
107
MCQhard

You are troubleshooting a performance issue in an AI application where dependency calls to Azure OpenAI take significantly longer during periods of high traffic. You want to query Log Analytics to find the 95th percentile (p95) duration of all dependency calls to Azure OpenAI over the past 24 hours. Which KQL query should you execute?

A.dependencies | where timestamp > ago(24h) | where target has 'openai' | summarize p95_duration = percentile(duration, 95) by target
B.exceptions | where timestamp > ago(24h) | summarize count() by outerType
C.requests | where timestamp > ago(24h) | summarize count() by resultCode
D.traces | where timestamp > ago(24h) | summarize avg(severityLevel) by message
AnswerA

Filtering dependencies by timestamp and target, then applying percentile(duration, 95) grouped by target, returns the p95 latency for Azure OpenAI calls. The percentile() aggregation is the specific function that computes the 95th percentile, satisfying the p95 requirement across the 24-hour window.

Why this answer

Dependency calls (including outbound calls to Azure OpenAI) are recorded in the Application Insights 'dependencies' table, which includes a 'target' field identifying the dependency endpoint and a 'duration' field in milliseconds. The percentile() aggregation function computes the 95th percentile, and filtering with 'target has openai' scopes the query to Azure OpenAI calls. This query directly answers the requirement.

Exam trap

The trap is selecting the wrong telemetry table — candidates often confuse 'requests' (inbound) with 'dependencies' (outbound) or reach for 'traces'/'exceptions' when the question is explicitly about outbound dependency latency percentiles.

How to eliminate wrong answers

Option B is wrong because the 'exceptions' table stores exception telemetry, not dependency durations, and 'outerType' groups by exception type — it cannot compute p95 latency. Option C is wrong because the 'requests' table records inbound server requests, not outbound dependency calls, and 'resultCode' is an HTTP status, not a latency metric. Option D is wrong because the 'traces' table holds diagnostic trace messages, and averaging 'severityLevel' produces a meaningless number unrelated to dependency duration.

Full explanation →
108
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
109
Multi-Selectmedium

You are building a container image for an AI application that will be deployed to Azure Container Instances (ACI). The image will be stored in Azure Container Registry (ACR). You need to ensure that the image can be pulled by ACI securely without embedding registry credentials in the image or in scripts. Which TWO of the following approaches can be used to authenticate ACI to ACR? (Choose two.)

Select 2 answers
A.Enable anonymous pull on the ACR instance so that ACI can pull images without authentication.
B.Create a service principal with the AcrPull role and use its credentials in the ACI deployment.
C.Use the Azure Container Registry's built-in token authentication with a scoped token stored in the container image.
D.Assign a managed identity to the ACI container group and grant it the AcrPull role on the ACR instance.
E.Use the ACR admin account username and password stored in Azure Key Vault and referenced in the ACI deployment.
AnswersB, D

You can create an Azure AD service principal, assign it the AcrPull role on the ACR, and provide its credentials (client ID and secret) in the ACI deployment configuration. This allows ACI to authenticate to ACR. While this method works, it requires managing the service principal secret, which can be rotated. It is a valid approach, though managed identity is often preferred for Azure resources.

Why this answer

ACI can authenticate to ACR using either a managed identity with the AcrPull role or a service principal with the AcrPull role. Both methods avoid embedding credentials in the image. Managed identity is preferred for Azure resources as it eliminates secret management.

The admin account is not recommended due to broad permissions, anonymous pull is insecure, and embedding tokens in images is a security risk.

Exam trap

The trap here is thinking that the ACR admin account is a secure and recommended method, but it has full registry access and is not scoped, making it less secure than managed identity or service principal.

Full explanation →
110
MCQmedium

You are building a chat application with memory using Azure AI Search. You want to retrieve previous conversation turns that are semantically similar to the current user prompt. What search mode should you use if you want to execute both a vector search and a keyword search simultaneously and combine their results?

A.Exhaustive k-NN search
B.Wildcard search
C.Hybrid search
D.Fuzzy search only
AnswerC

Hybrid search runs vector and keyword queries in parallel and merges the result sets using reciprocal rank fusion. That satisfies the requirement to combine semantic similarity with lexical matching in a single query against Azure AI Search, improving recall over either mode alone.

Why this answer

Hybrid search in Azure AI Search runs a vector (k-NN) query and a keyword (BM25) query in parallel against the same index, then merges the two result sets using Reciprocal Rank Fusion (RRF) to produce a single ranked list. This is exactly what the scenario requires: semantic similarity from embeddings plus lexical precision from keyword matching. It is the recommended default for chat-with-memory and RAG patterns because it captures both conceptual and exact-term matches.

Exam trap

AI-200 often tests the assumption that 'vector search' and 'hybrid search' are interchangeable — candidates pick exhaustive k-NN thinking it combines modes, when only hybrid search actually fuses vector and keyword results via RRF.

How to eliminate wrong answers

Option A is wrong because exhaustive k-NN only performs brute-force vector comparison over the entire vector space — it is a vector-only mode and does not execute keyword search or fuse results. Option B is wrong because wildcard search is a lexical query feature (e.g., 'eng*') that expands term matching in the inverted index; it has nothing to do with vector similarity or hybrid ranking. Option D is wrong because fuzzy search only handles lexical misspellings/typos via edit-distance expansion and does not perform vector search or RRF fusion.

Full explanation →
111
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
112
MCQeasy

Which distance metric in Azure Cosmos DB vector search calculates the shortest straight-line segment between two points in a multi-dimensional space?

A.dotproduct
B.hamming
C.cosine
D.euclidean
AnswerD

Euclidean distance measures the straight-line (L2) separation between two vectors in multi-dimensional space, matching the stem's requirement precisely. Cosmos DB offers it alongside cosine and dot product, so selecting euclidean satisfies the shortest straight-line segment criterion.

Why this answer

Euclidean distance (D) measures the straight-line (L2) distance between two vectors in multi-dimensional space, computed as the square root of the sum of squared differences across dimensions. It is the metric that literally corresponds to the geometric 'shortest straight-line segment' between two points, making it the correct answer for Cosmos DB vector search.

Exam trap

AI-200 often tests the confusion between distance metrics — candidates must know that euclidean is the literal straight-line L2 distance, while cosine measures angle and dotproduct measures projection.

How to eliminate wrong answers

Option A is wrong because dotproduct (inner product) measures the projection/alignment of one vector onto another and is sensitive to vector magnitude — it is not a straight-line distance and can be negative. Option B is wrong because hamming distance counts the number of differing positions between two equal-length strings or binary vectors, not a geometric distance in continuous multi-dimensional space. Option C is wrong because cosine similarity measures the angle between vectors (direction only, ignoring magnitude), not the straight-line segment separating them.

Full explanation →
113
Multi-Selectmedium

When configuring vector search in Azure AI Search, which TWO components are defined within the vectorSearch object of an index definition? (Choose two)

Select 2 answers
A.sqlPartitionKey
B.storageAccountConnectionString
C.algorithms
D.profiles
E.cosmosContainerName
AnswersC, D

The algorithms array sits inside the vectorSearch object and defines the approximate nearest neighbour method, such as HNSW or exhaustive KNN, that vector profiles reference. It satisfies the stem's requirement by being one of the two components configured directly within vectorSearch.

Why this answer

Option C (algorithms) is correct because the vectorSearch object in an Azure AI Search index definition contains an algorithms array where you configure the approximate nearest neighbor (ANN) algorithm used for vector indexing, such as HNSW (with parameters like m, efConstruction, efSearch) or exhaustive KNN. Option D (profiles) is correct because the same vectorSearch object contains a profiles array that defines named vector search profiles, each combining an algorithm configuration with a vectorizer, which fields then reference via their vectorSearchProfile property. Options A (sqlPartitionKey), B (storageAccountConnectionString), and E (cosmosContainerName) are incorrect because they are not properties of the vectorSearch object; they relate to data source or indexer configuration for external data stores (e.g., Azure SQL or Cosmos DB), not to vector search configuration within an index definition.

Exam trap

AI-200 often tests the confusion between index-level vector configuration (algorithms, profiles) and data source properties (sqlPartitionKey, storageAccountConnectionString, cosmosContainerName), causing candidates to incorrectly select data source elements as part of vectorSearch.

Full explanation →
114
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
115
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
116
Multi-Selecteasy

Which THREE of the following are components of a standard Dockerfile for an AI application?

Select 3 answers
A.CLUSTER_CREATE.
B.RUN (Installation of libraries/tools).
C.CMD/ENTRYPOINT (Process command).
D.FROM (Base image).
E.AZURE_LOGIN (Manual login).
AnswersB, C, D

RUN executes commands during image build, installing the Python libraries, CUDA toolkits and dependencies the AI application needs. This satisfies the build-time installation requirement, layering packages into the image before runtime rather than at container start.

Why this answer

Option D (FROM) is correct because every Dockerfile must begin with a FROM instruction that specifies the base image (e.g., FROM nvidia/cuda:12.2.0-runtime-ubuntu22.04 or FROM python:3.11-slim) on which the AI application's layers are built. Option B (RUN) is correct because RUN executes build-time commands inside the image, such as pip install torch tensorflow or apt-get install, to install the libraries and tools the AI application needs. Option C (CMD/ENTRYPOINT) is correct because these instructions define the process command that starts when the container launches, such as CMD ["python", "app.py"], which is essential for running the AI workload.

Option A (CLUSTER_CREATE) is not a Dockerfile instruction; it is a cluster-provisioning action performed by orchestration tooling, not image build syntax. Option E (AZURE_LOGIN) is not a Dockerfile instruction either; authentication to Azure is handled externally via the Azure CLI or service principals, not baked into the image build.

Exam trap

AI-200 often tests whether candidates can distinguish real Dockerfile instructions (FROM, RUN, CMD, ENTRYPOINT, COPY) from orchestration or cloud CLI commands (CLUSTER_CREATE, AZURE_LOGIN) that look plausible but are not part of the Dockerfile spec.

Full explanation →
117
MCQhard

You are running a GPU-intensive AI workload in AKS. You want to ensure the pods are scheduled only on nodes that have GPUs. How do you enforce this?

A.Use a DaemonSet.
B.Use a nodeSelector for 'sku=gpu'.
C.Define a Resource Request for RAM.
D.Add a Kubernetes Taint to the GPU nodes.
AnswerB

A nodeSelector in the pod spec constrains scheduling to nodes whose labels match sku=gpu, so the scheduler only places GPU pods on GPU-labelled nodes. This enforces the GPU-only placement constraint in AKS without relying on taints or affinity rules.

Why this answer

A nodeSelector in the pod spec constrains scheduling to nodes whose labels match the specified key-value pair, so 'sku=gpu' ensures the pod only lands on GPU-labeled nodes. This is the simplest and most direct scheduling constraint for hardware targeting in AKS. It works because the Kubernetes scheduler filters nodes by label before scoring them.

Exam trap

AI-200 often tests the confusion between taints (which repel pods) and nodeSelector/affinity (which attract pods) — candidates pick taints thinking they schedule workloads onto GPU nodes, when taints actually do the opposite.

How to eliminate wrong answers

Option A is wrong because a DaemonSet ensures one pod per node for cluster-wide agents like log collectors; it does not target GPU nodes specifically and would run on every node. Option C is wrong because a memory resource request only influences bin-packing and eviction, not which node type the pod lands on. Option D is wrong because a taint on GPU nodes repels pods that lack a matching toleration — it prevents scheduling rather than attracting pods to GPU nodes, and by itself does not guarantee placement on them.

Full explanation →
118
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
119
MCQmedium

You are using Azure OpenAI Service to generate embeddings for your documents before storing them in Azure Cosmos DB for NoSQL. The embedding model outputs vectors with a length of 1536. When defining the vector embedding policy in Cosmos DB, what value should you specify for the dimensions property?

A.3072
B.1536
C.512
D.768
AnswerB

The dimensions property must match the embedding model's output vector length exactly, since Cosmos DB validates every stored vector against this declared size. Specifying 1536 aligns the policy with the model's fixed 1536-dimension output, ensuring embeddings are accepted and vector search queries return correct results.

Why this answer

The dimensions property in Cosmos DB's vector embedding policy must match the exact length of the vectors produced by the embedding model. Since the Azure OpenAI embedding model outputs 1536-dimensional vectors, you must specify 1536. Mismatched dimensions cause indexing failures or query errors.

Exam trap

AI-200 often tests the assumption that dimensions can be arbitrary or that larger is better — the trap is not matching the dimensions exactly to the embedding model's output, which causes silent indexing failures.

How to eliminate wrong answers

Option A is wrong because 3072 corresponds to larger models like text-embedding-3-large, not the model described. Option C is wrong because 512 is not a standard dimension for Azure OpenAI embedding models. Option D is wrong because 768 is typical of some open-source models (e.g., BERT-based), not the Azure OpenAI model outputting 1536.

Full explanation →
120
Multi-Selecthard

You are configuring enterprise networking for an AKS cluster running sensitive AI models. Which THREE networking features should you implement for cluster security?

Select 3 answers
A.Public IP assignment to every worker node
B.Azure Firewall or user-defined routes for outbound egress filtering
C.Disabling all internal kube-dns resolution
D.Azure CNI Network Policies for pod-level traffic restriction
E.Private AKS API server endpoint
AnswersB, D, E

Azure Firewall and user-defined routes control outbound traffic from the AKS cluster, restricting egress to approved destinations. This satisfies the scenario's requirement for outbound egress filtering, preventing sensitive AI workloads from reaching unauthorised external endpoints.

Why this answer

Option B is correct because Azure Firewall or user-defined routes (UDRs) let you control and filter outbound egress traffic from the AKS cluster, preventing exfiltration of sensitive AI models and enforcing FQDN/network rules. Option D is correct because Azure CNI Network Policies enforce Kubernetes NetworkPolicy objects at the pod level, restricting east-west traffic between pods so compromised workloads cannot freely reach other services. Option E is correct because a private AKS API server endpoint exposes the control plane only via a private IP inside your VNet or peered network, removing public internet exposure of the Kubernetes API.

Option A is not appropriate because assigning public IPs to every worker node increases the attack surface and is unnecessary for secure egress. Option C is not appropriate because disabling all internal kube-dns resolution would break service discovery and core cluster functionality rather than improve security.

Exam trap

AI-200 often tests whether candidates can distinguish genuine security controls from operational misconfigurations, tempting them to select options like public IPs or disabling DNS that sound like 'network changes' but actually weaken or break the cluster.

Full explanation →
121
MCQeasy

Which tool in Azure Portal allows you to test search queries, inspect index schemas, and view JSON responses for Azure AI Search?

A.Metrics Advisor
B.Data Explorer
C.Log Analytics
D.Search explorer
AnswerD

Search explorer in the Azure portal lets you submit queries against an index, inspect its field schema, and view raw JSON responses, directly satisfying the need to test queries and examine index structure for Azure AI Search.

Why this answer

Search explorer is the built-in query console in the Azure portal for Azure AI Search. It lets you submit simple, full, or Lucene queries against a selected index, inspect the index schema (fields, attributes, analyzers), and view the raw JSON response documents returned by the service. This makes it the correct tool for testing search queries and validating index behavior directly from the portal.

Exam trap

AI-200 often tests whether candidates can distinguish Azure AI Search's own tooling (Search explorer, Import data wizard) from unrelated Azure monitoring and analytics services like Log Analytics, Metrics Advisor, and Data Explorer.

How to eliminate wrong answers

Option A is wrong because Metrics Advisor is an AIOps/anomaly-detection service for time-series monitoring data, not a search index query tool. Option B is wrong because Data Explorer in the Azure portal is associated with services like Azure Data Explorer (Kusto) and Log Analytics query experiences, not Azure AI Search index testing. Option C is wrong because Log Analytics is a monitoring service that stores and queries log/telemetry data using KQL, and has no role in querying Azure AI Search indexes.

Full explanation →
122
MCQeasy

You want to receive an email notification whenever monthly spending on your Azure OpenAI Service exceeds $5,000. Which Azure feature should you configure?

A.Azure Service Health incident alert
B.Cost Management budget with an alert threshold set at the desired dollar amount
C.Azure Advisor security recommendation
D.Azure Monitor Metric alert on CPU utilization
AnswerB

A Cost Management budget tracks actual or forecast spend against a scope and fires alerts when a configured threshold, such as $5,000, is crossed. It satisfies the stem's requirement to notify by email when monthly Azure OpenAI Service spending exceeds that amount.

Why this answer

Azure Cost Management budgets allow you to define spending thresholds and attach action groups or email recipients for notifications.

Full explanation →
123
MCQhard

Your containerized AI application requires a specific version of a kernel driver that is not installed on the AKS nodes. What is the most efficient way to manage this?

A.Mount the /proc filesystem as read-write.
B.Run the application as root.
C.Use a privileged InitContainer to load the driver.
D.Rebuild the AKS cluster.
AnswerC

A privileged InitContainer runs before the main application container, letting it install the required kernel driver directly onto the node's host filesystem. This satisfies the stem's constraint that the driver is missing from AKS nodes without rebuilding node images.

Why this answer

A privileged InitContainer runs before the main application container and, with privileged security context, can load kernel modules (e.g., via modprobe or insmod) onto the node. This is the standard Kubernetes pattern for node-level setup that must complete before the workload starts. It is more efficient than rebuilding the cluster and avoids granting the application container itself elevated privileges.

Exam trap

AI-200 often tests the confusion between container-level privilege (running as root) and node-level privilege (privileged container with CAP_SYS_MODULE), leading candidates to pick 'run as root' as a shortcut.

How to eliminate wrong answers

Option A is wrong because mounting /proc read-write does not grant the capability to load kernel modules — module loading requires CAP_SYS_MODULE and privileged access, not just filesystem permissions. Option B is wrong because running the application as root does not by itself allow kernel module insertion; root inside a container is still constrained by namespaces and dropped capabilities unless the container is privileged. Option D is wrong because rebuilding the AKS cluster is a drastic, slow operation that does not address ongoing driver management and would need to be repeated for every driver update.

Full explanation →
124
MCQeasy

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

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

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

Why this answer

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

No additional configuration is needed to use this default schema.

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
125
Multi-Selecthard

You need to secure an Azure Machine Learning workspace against data exfiltration. Which THREE configurations should you implement?

Select 3 answers
A.Disable public network access on the Azure Machine Learning workspace.
B.Assign the Contributor role to all users on the subscription level.
C.Attach public IP addresses to all compute instances for rapid troubleshooting.
D.Configure a managed virtual network for the workspace with approved outbound rules.
E.Enable private endpoints for all dependent services such as Azure Storage, Key Vault, and Azure Container Registry.
AnswersA, D, E

Disabling public network access removes the internet-facing endpoint entirely, so workspace traffic must traverse private connectivity. This directly blocks exfiltration paths that rely on reaching the workspace over public IP addresses, satisfying the requirement to prevent outbound data leakage.

Why this answer

Option A is correct because disabling public network access on the Azure Machine Learning workspace forces all client and service traffic through private endpoints or approved private paths, eliminating the public internet as an exfiltration route. Option D is correct because a workspace managed virtual network isolates compute and uses approved outbound rules (via private endpoints or FQDNs), preventing compute from sending data to unapproved external destinations. Option E is correct because private endpoints for dependent services such as Azure Storage, Key Vault, and Azure Container Registry keep that traffic on the Microsoft backbone/private IP space, so data cannot be exfiltrated through those services' public endpoints.

Option B is incorrect because granting Contributor at subscription scope broadens access and violates least privilege rather than securing against exfiltration. Option C is incorrect because attaching public IP addresses to compute instances exposes them to inbound/outbound internet traffic and increases exfiltration risk.

Exam trap

AI-200 often tests whether candidates pick 'more permissions' or 'public IPs for troubleshooting' as security measures — the exam expects recognition that exfiltration protection is about removing public exposure, not adding access.

Full explanation →
126
MCQmedium

You are writing a query in Azure Cosmos DB for NoSQL that sorts results by vector similarity and also filters results by a category property. How must you order the clauses in your SQL statement?

A.The WHERE clause must come before the ORDER BY VectorDistance() clause
B.VectorDistance must be placed in the SELECT clause instead of ORDER BY
C.WHERE and ORDER BY clauses cannot be used in the same query when using vectors
D.The ORDER BY clause must come before the WHERE clause
AnswerA

Placing WHERE before ORDER BY VectorDistance() satisfies the stem's requirement to filter by category and then rank by similarity. Cosmos DB evaluates the filter first, reducing the candidate set, then computes vector distance for ordering. Reversing them would attempt sorting before filtering, which the SQL grammar rejects.

Why this answer

In Azure Cosmos DB for NoSQL, SQL clause order is fixed: SELECT, FROM, WHERE, ORDER BY. When using VectorDistance() in ORDER BY, the WHERE clause must still appear before ORDER BY, so filtering by category happens first and then results are sorted by vector similarity. This is standard SQL clause ordering, not a vector-specific exception.

Exam trap

The trap is thinking vector queries have special syntax rules that override standard SQL clause order — candidates may pick 'ORDER BY before WHERE' or assume the clauses cannot coexist.

How to eliminate wrong answers

Option B is wrong because VectorDistance() in the SELECT clause would compute the distance but not sort by it — you need ORDER BY to rank results by similarity. Option C is wrong because WHERE and ORDER BY can absolutely be combined with vector queries; the restriction is only on clause order. Option D is wrong because placing ORDER BY before WHERE violates SQL syntax and would produce a parse error.

Full explanation →
127
MCQeasy

You need to monitor the monthly spending on Azure OpenAI token consumption and receive an alert when expenditures exceed a predefined threshold. Which tool should you use?

A.Azure Cost Management Budgets and Alerts
B.Log Analytics Workspace usage and estimated costs view
C.Application Insights availability tests
D.Azure Security Center compliance dashboard
AnswerA

Azure Cost Management Budgets let you set a monthly spend threshold scoped to Azure OpenAI resources and trigger alerts when actual or forecast cost exceeds it, directly satisfying the requirement to monitor token consumption spending and receive threshold alerts.

Why this answer

Azure Budgets in Cost Management allow you to set spending thresholds and automated email alerts when thresholds are reached.

Full explanation →
128
Multi-Selecthard

You are configuring diagnostic logging for an enterprise Azure OpenAI Service deployment. You need to forward logs to multiple destinations for security analysis and archiving. Which THREE of the following destinations are supported by Azure Monitor diagnostic settings? (Choose three)

Select 3 answers
A.Azure Event Hubs
B.Azure Storage account
C.Log Analytics workspace
D.Azure Container Registry local image cache
E.Azure Bastion host memory dump
AnswersA, B, C

Azure Monitor diagnostic settings natively stream resource logs and metrics to Azure Event Hubs, which satisfies the stem's security-analysis requirement by feeding third-party SIEM and streaming platforms at scale. Event Hubs is one of the three supported destinations alongside Log Analytics and Storage.

Why this answer

Diagnostic settings support routing logs and metrics to Log Analytics workspaces, Azure Storage accounts, and Azure Event Hubs.

Full explanation →
129
Multi-Selectmedium

Which TWO of the following are valid autoscaling options for AKS?

Select 2 answers
A.Cluster Autoscaler (CA).
B.Manual registry scaling.
C.Horizontal Pod Autoscaler (HPA).
D.Storage capacity scaling.
E.Azure Service Bus scaling.
AnswersA, C

Cluster Autoscaler adjusts the number of nodes in the AKS node pool when pods cannot be scheduled due to insufficient resources, scaling infrastructure rather than replicas. It is a native AKS autoscaling option, satisfying the question's requirement for valid autoscaling options.

Why this answer

Option A, Cluster Autoscaler (CA), is correct because it is a built-in AKS feature that automatically adjusts the number of nodes in a node pool based on pending pod resource requests and node utilization, scaling the cluster infrastructure up or down within configured min/max bounds. Option C, Horizontal Pod Autoscaler (HPA), is correct because it is a native Kubernetes autoscaling mechanism supported in AKS that scales the number of pod replicas in a Deployment, ReplicaSet, or StatefulSet based on observed metrics such as CPU, memory, or custom metrics. The other options are not valid AKS autoscaling options: manual registry scaling (B) is not an autoscaling feature at all, storage capacity scaling (D) refers to resizing persistent volumes rather than automatically scaling compute workloads, and Azure Service Bus scaling (E) is a messaging service concern, not an AKS autoscaling mechanism.

Exam trap

AI-200 often tests the confusion between pod-level and node-level autoscaling — candidates mistakenly pick storage or messaging options that sound like scaling but are not AKS autoscaling primitives.

Full explanation →
130
MCQeasy

In Azure Cosmos DB for NoSQL, which property in the container definition specifies the path to the property containing the vector array within each document?

A.path
B.propertyLocation
C.field
D.jsonPath
AnswerA

Within the vector embedding policy, the path property names the document field holding the vector array, for example /embedding. Cosmos DB reads that JSON pointer to index the vector, so queries can perform similarity search against it.

Why this answer

In Azure Cosmos DB for NoSQL, the vector embedding policy is defined inside the container's vectorEmbeddingPolicy, and each vector path is declared using the 'path' property, which points to the JSON property in each document that holds the vector array (for example, /embedding). This 'path' value is what the query engine uses to locate the vector for VectorDistance() operations. The other names are not part of the Cosmos DB vector schema.

Exam trap

AI-200 often tests whether candidates confuse the Cosmos DB vector policy field name 'path' with generic JSONPath or property-location terminology from other Azure services.

How to eliminate wrong answers

Option B is wrong because 'propertyLocation' is not a valid Cosmos DB vector policy field — the actual field is 'path'. Option C is wrong because 'field' is not used in the vector embedding policy schema; Cosmos DB uses 'path' with a leading slash. Option D is wrong because 'jsonPath' is a JSONPath terminology used in other systems (and in some Cosmos DB contexts), but the vector embedding policy specifically uses 'path', not 'jsonPath'.

Full explanation →
131
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
132
MCQmedium

You need to deploy a real-time object detection model inside an Azure Container App. The application requires immediate scale-out when the queue length of incoming image processing requests exceeds a threshold. Which scaling rule type should you configure?

A.Azure Queue Storage / Service Bus KEDA scaling rule
B.Memory utilization scaling rule
C.CPU utilization scaling rule
D.HTTP concurrency scaling rule
AnswerA

A KEDA queue scaler polls Azure Queue Storage or Service Bus and drives replica count from message backlog, so scale-out triggers the moment queue length crosses your threshold. This satisfies the stem's demand for immediate, event-driven scaling of the containerised object detection workload, unlike CPU or HTTP-based rules that lag behind queue depth.

Why this answer

Azure Container Apps uses KEDA (Kubernetes Event-Driven Autoscaling) scalers to scale based on external event sources. A queue-length trigger from Azure Queue Storage or Service Bus is the correct KEDA scaler when the workload must scale out in response to the number of pending messages, which matches the requirement of scaling when image processing requests exceed a threshold.

Exam trap

The trap here is that candidates often pick CPU or memory scalers because they assume resource pressure equals demand, but AI-200 tests the distinction between event-driven (KEDA) and resource-driven scaling for asynchronous workloads.

How to eliminate wrong answers

Option B is wrong because memory utilization is a resource-based metric that reacts to consumption inside the container, not to the arrival rate of queued requests, so it cannot provide immediate scale-out on queue depth. Option C is wrong for the same reason — CPU utilization lags behind the actual queue buildup and may not trigger until the container is already saturated. Option D is wrong because HTTP concurrency scales on simultaneous inbound HTTP connections, which is useful for synchronous APIs but does not reflect the backlog of asynchronous image processing requests sitting in a queue.

Full explanation →
133
MCQmedium

An enterprise application uses Azure AI Search and needs to authenticate securely to an Azure OpenAI backend without exposing credentials in connection strings. What is the recommended approach?

A.Create a shared access signature (SAS) token for the Azure OpenAI endpoint and rotate it every 30 days.
B.Configure a system-assigned managed identity on the Azure AI Search service and assign the Cognitive Services OpenAI User role on the Azure OpenAI resource.
C.Use HTTP basic authentication with a pre-shared service principal secret.
D.Store the Azure OpenAI primary key in an Azure App Configuration service and reference it via Key Vault.
AnswerB

A system-assigned managed identity gives Azure AI Search an identity in Microsoft Entra ID, so it requests tokens for Azure OpenAI without stored secrets. Assigning the Cognitive Services OpenAI User role on the OpenAI resource grants least-privilege data-plane access, satisfying the no-credentials-in-connection-strings constraint.

Why this answer

A system-assigned or user-assigned managed identity should be enabled on the Azure AI Search service and granted the Cognitive Services OpenAI User role on the Azure OpenAI resource.

Full explanation →
134
MCQmedium

You are troubleshooting a containerized AI model running in an Azure Container App that crashes immediately upon startup with an exit code indicating an Out Of Memory (OOM) error. You need to inspect the container resource allocations. Where can you adjust the memory allocation for the container?

A.In the Azure Container Registry webhook configuration
B.In the Azure Container App revision template settings under container resource allocation
C.In the Azure Virtual Network route table settings
D.In the Azure Monitor diagnostic settings export destination
AnswerB

Memory and CPU limits are configured per container in the revision template's container resource allocation section. Raising the memory limit there resolves the OOM exit, directly satisfying the stem's requirement to inspect and adjust container resource allocations.

Why this answer

Azure Container Apps defines resource allocations (CPU cores and memory) per container inside the revision template. To fix an OOM crash, you edit the container's resources.requests (or the equivalent cpu/memory fields) in the revision template, which creates a new revision with the increased memory limit.

Exam trap

AI-200 often tests the misconception that resource limits can be adjusted via monitoring or networking settings, when they are strictly defined in the Container App revision template.

How to eliminate wrong answers

Option A is wrong because ACR webhooks trigger actions on image push/pull events and have no relationship to container runtime resource limits. Option C is wrong because VNet route tables control network traffic routing (UDRs) and cannot influence container memory allocation. Option D is wrong because Azure Monitor diagnostic settings control where telemetry (logs, metrics) is exported — they observe resource usage but do not configure it.

Full explanation →
135
MCQeasy

You want to view an end-to-end distributed trace of a user request flowing from an Azure Front Door through an API Management gateway, into an Azure Function, and finally to an Azure OpenAI model call. Which Application Insights feature visualizes this entire call chain and highlights latency bottlenecks?

A.Azure Cost Analysis
B.Azure Advisor security recommendations
C.Azure Policy compliance dashboard
D.Application Map and Transaction Diagnostics
AnswerD

Application Map renders the discovered components and their dependency calls as a topology, while Transaction Diagnostics drills into a single end-to-end trace, showing each span's duration. Together they expose where latency accumulates across Front Door, API Management, Functions, and Azure OpenAI.

Why this answer

Application Map in Application Insights visualizes the topology of distributed components and their call relationships, while Transaction Diagnostics drills into a single end-to-end transaction to show each dependency call and its latency. Together they trace a request from Front Door through APIM, Functions, and Azure OpenAI, highlighting the slowest hop.

Exam trap

AI-200 often tests whether candidates know that Application Map and Transaction Diagnostics are the tracing features, while Cost Analysis, Advisor, and Policy are governance/cost tools that cannot visualize request latency.

How to eliminate wrong answers

Option A is wrong because Azure Cost Analysis reports spending, not request traces or latency. Option B is wrong because Azure Advisor security recommendations are posture suggestions, not distributed tracing. Option C is wrong because Azure Policy compliance dashboards show governance state, not runtime call chains.

Full explanation →
136
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
137
MCQmedium

You are building a RAG solution on Azure AI Search. Documents and their embeddings are updated frequently, and you need the vector index to reflect changes within seconds without rebuilding the entire index. Which indexer behavior should you configure?

A.Use a custom skill that writes embeddings directly to the index bypassing the indexer pipeline.
B.Enable incremental enrichment and run the indexer on a schedule with change detection policies.
C.Set the indexer to run once manually after each document update via the Azure portal.
D.Recreate the vector index and re-upload all embeddings whenever a document changes.
AnswerB

Incremental enrichment allows the indexer to process only documents that have changed since the last run, and change detection policies (such as high water mark or soft delete) ensure that updates and deletions are picked up efficiently. This avoids full rebuilds and keeps the vector index synchronized with source data on a recurring schedule, meeting the near-real-time requirement.

Why this answer

Incremental enrichment combined with change detection policies allows the indexer to identify and process only modified or deleted documents, updating the vector index efficiently. Scheduling the indexer ensures periodic synchronization without full rebuilds. This is the recommended approach for RAG pipelines that need fresh embeddings with minimal latency and resource consumption.

Exam trap

The trap here is assuming that any indexer run will automatically detect changes, when change detection policies must be explicitly configured to avoid full reindexing.

Full explanation →
138
MCQmedium

You are writing a Python application using the Azure Cosmos DB Python SDK to perform a vector search. You execute a parameterized SQL query containing VectorDistance(). What must be passed as a query parameter for the VectorDistance function to evaluate correctly against the container's vector property?

A.A base64 encoded string of the text
B.A connection string to Azure OpenAI Service
C.A Python list of float values representing the query embedding
D.A file path pointing to a local .npy numpy file
AnswerC

VectorDistance expects the query embedding as a JSON array of numbers, so the SDK parameter must be a Python list of floats; passing a string or tuple fails to serialise into the numeric array the function compares against the stored vector.

Why this answer

VectorDistance() in the Cosmos DB Python SDK expects the query embedding as a native array of floats, which the SDK serializes to the JSON array the server compares against the stored vector property. Passing a Python list of floats (C) is the correct and only supported form for the parameter. The function then computes cosine, dot product, or Euclidean distance per the container's vector policy.

Exam trap

AI-200 often tests the misconception that embeddings can be passed as encoded strings or file references, when the SDK requires a plain list of floats matching the container's vector policy.

How to eliminate wrong answers

Option A is wrong because base64 encoding is a transport encoding, not a numeric vector; the server cannot compute distance over an encoded string. Option B is wrong because a connection string is a credential, not embedding data, and is irrelevant to the query parameter. Option D is wrong because a file path is a client-side reference; the SDK does not read .npy files, and the server never sees local paths.

Full explanation →
139
MCQeasy

You need to view real-time log streams from an Azure Container App running a custom LangChain agent. Which Azure CLI command should you execute?

A.az cognitiveservices account log-stream --name <account-name>
B.az containerapp logs show --name <app-name> --resource-group <rg-name> --follow
C.az aks browsed --name <cluster-name>
D.az monitor metrics tail --resource <resource-id>
AnswerB

The --follow flag streams live output rather than returning a static snapshot, and az containerapp logs show targets the Container App's console output directly. This satisfies the real-time requirement without needing Log Analytics queries or a separate monitoring workspace.

Why this answer

The Azure CLI command 'az containerapp logs show' retrieves logs from a Container App, and the '--follow' flag streams them in real time (similar to tail -f). This is the correct command to view live log output from a running Container App hosting a LangChain agent.

Exam trap

AI-200 often tests whether candidates know the correct Azure CLI verb-noun structure for Container Apps versus AKS versus Cognitive Services — the trap is picking a plausible-sounding but non-existent command like 'az cognitiveservices account log-stream' or 'az monitor metrics tail'.

How to eliminate wrong answers

Option A is wrong because 'az cognitiveservices account log-stream' is not a valid command — Cognitive Services accounts do not expose a log-stream subcommand, and this would not target a Container App. Option C is wrong because 'az aks browsed' is not a real command (the actual command is 'az aks browse', which opens the Kubernetes dashboard and is deprecated), and it targets AKS clusters, not Container Apps. Option D is wrong because 'az monitor metrics tail' is not a valid command — Azure Monitor metrics are queried via 'az monitor metrics list', and metrics are numeric time-series data, not log streams.

Full explanation →
140
Multi-Selectmedium

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

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

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

Why this answer

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

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

Exam trap

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

Full explanation →
141
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
142
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
143
Multi-Selecthard

You are designing a high-scale vector search architecture using Azure AI Search. Which THREE operational and architectural best practices should you follow to ensure optimal performance and cost-efficiency? (Choose three)

Select 3 answers
A.Balance replica and partition counts based on your query throughput and index size requirements
B.Store all raw PDF files inside the vector float32 array fields
C.Use scalar quantization to reduce memory footprint and improve HNSW search throughput
D.Monitor search unit resource utilization (CPU, memory, storage) using Azure Monitor
E.Deploy all indexes on the Free tier to eliminate infrastructure costs
AnswersA, C, D

Replicas serve query throughput and partitions divide index storage; mismatching them wastes cost or throttles queries. Sizing both against measured query load and index size satisfies the optimal performance and cost-efficiency constraint for high-scale vector search in Azure AI Search.

Why this answer

Option A is correct because Azure AI Search scales along two independent dimensions: replicas provide query throughput and high availability, while partitions provide index storage and write parallelism, so right-sizing both to your QPS and index size is the core capacity-planning practice. Option C is correct because scalar quantization compresses float32 vectors to narrower types (for example int8), cutting memory usage and speeding up HNSW graph traversal with only modest recall loss, which improves cost-efficiency at high scale. Option D is correct because Azure Monitor exposes search unit metrics such as CPU, memory, and storage utilization, letting you detect saturation and resize replicas or partitions before performance degrades.

Option B is wrong because vector fields hold numeric embeddings, not raw PDF binaries, which belong in blob storage or a separate content field. Option E is wrong because the Free tier has no SLA, tiny storage and index limits, and cannot support a high-scale production workload.

Exam trap

The trap is treating the Free tier or raw document storage as viable for high-scale vector search; the exam expects you to know that replicas/partitions, quantization, and monitoring are the levers for performance and cost.

Full explanation →
144
MCQmedium

You are writing a Python script to query an Azure AI Search index using the azure-search-documents SDK. You want to retrieve both vector matches and keyword matches using hybrid search. Which class should you instantiate to represent the vector query?

A.EmbeddingQueryClient
B.HnswSearchRequest
C.CosmosVectorSearch
D.VectorizedQuery
AnswerD

VectorizedQuery carries the query vector and k-nearest-neighbours parameters for the search client, enabling hybrid retrieval alongside keyword search text. This satisfies the requirement to represent the vector portion of a hybrid query in the azure-search-documents SDK.

Why this answer

In the azure-search-documents Python SDK, a vector query is represented by the VectorizedQuery class, which holds the embedding vector, the k-nearest-neighbors count, and the fields to search. You pass a list of VectorizedQuery objects to the search client's search method alongside a keyword query string to perform hybrid search. This class is the SDK's canonical representation of a vector query payload.

Exam trap

AI-200 often tests whether candidates know the exact SDK class names — distractors like HnswSearchRequest sound plausible because HNSW is a real Azure AI Search algorithm, but it is an index configuration, not a query class.

How to eliminate wrong answers

Option A is wrong because EmbeddingQueryClient is not a class in the azure-search-documents SDK — embeddings are generated externally (e.g., via Azure OpenAI) and supplied as vectors. Option B is wrong because HnswSearchRequest is not a real SDK class; HNSW is the approximate nearest neighbor algorithm configured in the index, not a query request type. Option C is wrong because CosmosVectorSearch is not part of the Azure AI Search SDK — it conflates Azure Cosmos DB vector search with Azure AI Search.

Full explanation →
145
MCQhard

You are configuring network security for an Azure AI Search service that indexes data from an Azure SQL Database. Both services are in the same region. You want to ensure that Azure AI Search can securely connect to Azure SQL Database without allowing inbound traffic from any public IP addresses. Which feature should you use on Azure SQL Database?

A.Open firewall port 1433 for all IP addresses globally
B.Use Azure Front Door to load balance SQL TCP connections
C.Allow Azure services and resources to access this server firewall setting combined with Virtual Network rules
D.Configure an HTTP proxy inside an Azure VM to forward SQL queries
AnswerC

Correct. This setting allows trusted Azure services (like Azure AI Search) to connect to Azure SQL securely without opening the database to the public internet.

Why this answer

Service endpoints or private endpoints on Azure SQL Database allow Azure services (such as AI Search) to connect securely within the Microsoft backbone network while disabling public access.

Full explanation →
146
MCQmedium

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

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

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

Why this answer

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

This reduces unnecessary invocations and aligns with the requirement.

Exam trap

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

Full explanation →
147
MCQmedium

You are designing an AI search architecture that requires handling millions of documents with sub-second vector similarity queries. You choose Azure AI Search. How does Azure AI Search ensure high query throughput for vector indexes?

A.By caching every possible query result indefinitely in memory
B.By executing sequential full table scans across all storage nodes simultaneously
C.By utilizing HNSW approximate nearest neighbor indexing combined with multi-replica scale-out
D.By converting all vectors into relational database tables with SQL foreign keys
AnswerC

HNSW provides approximate nearest neighbour search, trading exact recall for logarithmic query latency, while multiple replicas distribute query load across partitions. Together they satisfy the sub-second latency requirement at millions-of-documents scale, since a single replica could not sustain that throughput.

Why this answer

Azure AI Search ensures high query throughput for vector indexes by using HNSW approximate nearest neighbor indexing, which builds a navigable graph for fast similarity search, combined with multi-replica scale-out that distributes query load across replicas. This architecture supports sub-second queries over millions of documents.

Exam trap

AI-200 often tests the misconception that vector search uses brute-force scans or relational tables; candidates must recognize HNSW and replica scale-out as the correct mechanisms.

How to eliminate wrong answers

Option A is wrong because caching every possible query result indefinitely is infeasible and not how Azure AI Search works; it uses caching selectively, not for all queries. Option B is wrong because sequential full table scans are the opposite of efficient vector search; HNSW avoids full scans. Option D is wrong because converting vectors to relational tables with foreign keys does not support vector similarity search and would be extremely inefficient.

Full explanation →
148
MCQmedium

Your Python-based AI service runs on an Azure Virtual Machine and connects to Azure OpenAI. To adhere to security best practices, you decide to eliminate storage of credentials on the VM disk by enabling a system-assigned managed identity on the virtual machine. How does your Python code obtain an access token using this managed identity?

A.Use static storage account connection strings hardcoded in environment variables
B.Make an unauthenticated HTTP GET request to the public Azure OpenAI endpoint with no headers
C.Use DefaultAzureCredential from the azure-identity library to automatically authenticate via the VM's IMDS endpoint
D.Read the plain-text password from a file located in /etc/passwd on the virtual machine
AnswerC

DefaultAzureCredential chains credential types and, on an Azure VM, resolves to ManagedIdentityCredential, which requests a token from the Instance Metadata Service endpoint at 169.254.169.254. This satisfies the requirement to eliminate credentials on the VM disk, since authentication relies on the platform-issued system-assigned identity rather than stored secrets.

Why this answer

The correct method is to use DefaultAzureCredential from the azure-identity library to automatically authenticate via the VM's IMDS endpoint. When a system-assigned managed identity is enabled on an Azure VM, the VM can request tokens from the Instance Metadata Service (IMDS) at a well-known endpoint (169.254.169.254). DefaultAzureCredential automatically detects the managed identity and uses it to obtain an access token for Azure OpenAI, eliminating the need to store credentials on the VM.

Exam trap

AI-200 often tests the misconception that managed identities require explicit credential storage or that DefaultAzureCredential does not automatically use IMDS, leading candidates to choose insecure options.

How to eliminate wrong answers

Option A is wrong because using static storage account connection strings hardcoded in environment variables stores credentials on the VM, which violates the requirement to eliminate credential storage. Option B is wrong because making an unauthenticated HTTP GET request to the public Azure OpenAI endpoint with no headers will fail; Azure OpenAI requires authentication via API key or Azure AD token. Option D is wrong because reading a plain-text password from /etc/passwd is not only insecure but also incorrect; /etc/passwd does not store passwords in plain text (they are in /etc/shadow), and this does not use managed identity.

Full explanation →
149
MCQmedium

Your company policy requires all outbound traffic from an Azure Machine Learning workspace to pass through a centralized firewall. Which feature must be implemented?

A.Enable public network access with selected IP addresses set to the firewall IP.
B.Use Azure Bastion to inspect all outbound connections from the workspace nodes.
C.Configure workspace outbound rules with fully qualified domain name (FQDN) tags and route traffic through Azure Firewall.
D.Deploy the workspace without virtual network isolation and rely on Network Security Groups.
AnswerC

FQDN tags in workspace outbound rules let Microsoft Entra ID-authenticated managed virtual networks forward traffic to Azure Firewall, satisfying the policy that all outbound traffic traverses a centralized firewall. Unlike service endpoints or private endpoints, this routes egress through the firewall rather than bypassing it.

Why this answer

To force all outbound traffic from an Azure Machine Learning workspace through a centralized firewall, you must configure workspace outbound rules using FQDN tags and route traffic through Azure Firewall. This is done by placing the workspace in a virtual network with a user-defined route (UDR) that points to Azure Firewall as the next hop, and then using Azure Firewall FQDN tags (such as AzureML) to allow required outbound traffic. This ensures that all egress is inspected and controlled by the firewall.

Exam trap

AI-200 often tests the misconception that NSGs or public network access settings can enforce outbound traffic inspection, when in fact a UDR to a firewall with FQDN tags is required for centralized egress control.

How to eliminate wrong answers

Option A is wrong because enabling public network access with selected IP addresses only restricts inbound access to the workspace; it does not route outbound traffic through a firewall. Option B is wrong because Azure Bastion provides secure RDP/SSH access to virtual machines, not outbound traffic inspection for a machine learning workspace. Option D is wrong because deploying without virtual network isolation and relying on NSGs does not provide centralized firewall inspection; NSGs are basic stateful packet filters and cannot enforce FQDN-based egress policies.

Full explanation →
150
Multi-Selectmedium

Your Azure AI application encounters transient network errors when calling cognitive services. Which TWO strategies should you implement in your code or architecture to handle these failures gracefully? (Choose two)

Select 2 answers
A.Disable all exception handling so unhandled errors crash the server.
B.Implement fallback routing or secondary region endpoints for high availability.
C.Terminate the application process immediately on the first transient timeout.
D.Configure SDK retry policies with exponential backoff and jitter for HTTP 429 and 503 errors.
E.Remove all timeout configurations from HTTP client connections.
AnswersB, D

Fallback routing redirects requests to a secondary region endpoint when the primary is unavailable, maintaining availability during regional outages or sustained throttling. It satisfies the stem's requirement for graceful failure handling at the architecture layer, complementing in-code retry policies.

Why this answer

Implementing retry logic with exponential backoff in SDK clients and configuring circuit breaker patterns or fallback endpoints helps handle transient failures.

Full explanation →
Page 1

Page 2 of 6

Page 3

All pages

123456

Practice AI-200 by domain

Target a specific domain to shore up weak areas.

Security And ObservabilityEvent Driven IntegrationData Management Services And Vector SearchContainerized AI Workloads
See all domains with question counts →