Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) AI-200 Questions 376–418 | Page 6/6

376

Multi-Selecthard

You are optimizing an Azure Cosmos DB for NoSQL vector search container. Which THREE properties must be correctly configured inside the vectorEmbeddingPolicy JSON object? (Choose three)

Select 3 answers

A.path

B.httpPort

C.dataType

D.distanceFunction

E.sslEnabled

AnswersA, C, D

path identifies the document property holding the vector array, telling Cosmos DB which field to index for vector search. Without it the policy cannot locate embeddings, so it must be configured as the stem demands.

Why this answer

The vectorEmbeddingPolicy JSON object in an Azure Cosmos DB for NoSQL container requires three properties: path, dataType, and distanceFunction. Option A (path) is correct because it specifies the JSON path to the array property in each document that holds the vector embedding, such as "/embedding". Option C (dataType) is correct because it defines the data type of the vector elements, with supported values like float32, float16, int8, and uint8, which must match the stored vector data.

Option D (distanceFunction) is correct because it specifies the similarity metric used for vector search, such as cosine, dotproduct, or euclidean, and is required for the index to compute nearest neighbors. Options B (httpPort) and E (sslEnabled) are not part of the vectorEmbeddingPolicy; these are connection or endpoint settings, not properties of the vector embedding policy JSON object.

Exam trap

The trap is confusing networking or security properties (httpPort, sslEnabled) with vector-specific configuration — candidates who have seen Cosmos DB connection strings may mistakenly include them.

Full explanation →

377

MCQhard

You are designing an IoT data ingestion architecture using Azure Event Hubs. Devices occasionally send malformed JSON payloads that cause stream processing jobs to crash. You need to route these invalid messages to a separate error container without stopping the main ingestion stream. What should you implement?

A.Enable Event Hubs Capture with the JSON validation flag set to strict.

B.Set up an Event Grid system topic filter for 'MalformedEvent'.

C.Configure the Service Bus dead-letter queue on the Event Hub producer client.

D.Use Azure Stream Analytics with an error output data stream configured for malformed events.

AnswerD

Azure Stream Analytics supports error handling configurations on data outputs, allowing streaming errors to be redirected to a separate blob storage sink.

Why this answer

Azure Stream Analytics supports an error output data stream that captures malformed or deserialization-failed events, allowing the main query to continue processing valid events while routing bad records to a separate sink (e.g., Blob Storage container). This is the documented pattern for handling malformed JSON without stopping the stream. Configuring the error output to point at an 'error' container satisfies the requirement.

Exam trap

The trap is assuming Event Hubs itself can validate JSON or dead-letter malformed messages; Event Hubs is a dumb pipe, and the routing/validation must be done by the stream processing layer (Stream Analytics error output).

How to eliminate wrong answers

Option A is wrong because Event Hubs Capture has no 'JSON validation flag set to strict' — Capture simply writes raw events to Blob/ADLS in Avro format and does not validate or route malformed payloads. Option B is wrong because Event Grid system topics surface control-plane events (e.g., capture file created), not per-message malformed JSON detection, and there is no 'MalformedEvent' filter. Option C is wrong because Service Bus dead-letter queues apply to Service Bus queues/subscriptions, not Event Hubs producers; Event Hubs has no DLQ concept for producers.

Full explanation →

378

MCQeasy

You are managing costs for multiple Azure AI services used by different business units. You need to track expenditure against specific departmental budgets and receive automated alerts when spending exceeds 80% of the allocated budget. Which Azure feature should you use?

A.Azure Advisor cost recommendations

B.Azure Monitor autoscale settings

C.Azure Cost Management Budgets with alert conditions

D.Azure Service Health alerts

AnswerC

Azure Cost Management Budgets let you set a monetary threshold scoped to a department and trigger alert conditions when actual or forecast spend reaches 80%. This directly satisfies the requirement to track expenditure against specific budgets with automated notifications.

Why this answer

Azure Cost Management Budgets let you define a monetary threshold scoped to a subscription, resource group, or specific resource, and attach alert conditions (e.g., 80% of budget) that fire via email or Action Groups. This is the only native Azure feature that directly ties spend tracking to a departmental budget with automated threshold alerts. Budgets can be filtered by tag, resource group, or service, so each business unit's AI spend can be isolated.

Exam trap

The trap here is confusing cost governance features (Budgets, Advisor) with operational monitoring features (Azure Monitor, Service Health) — only Budgets actually enforce spend thresholds with alerts.

How to eliminate wrong answers

Option A is wrong because Azure Advisor cost recommendations only surface optimization suggestions (e.g., right-size VMs); they do not track spend against a budget or send threshold alerts. Option B is wrong because Azure Monitor autoscale adjusts resource instance counts based on load metrics, not monetary budgets. Option D is wrong because Azure Service Health alerts notify about platform incidents and planned maintenance, not cost thresholds.

Full explanation →

379

Multi-Selectmedium

Your company policy requires securing AI model endpoints by disabling public internet access and ensuring all API requests use secure managed identities. Which TWO actions must you take? (Choose two)

Select 2 answers

A.Disable public network access on the Azure AI service resource and configure a private endpoint.

B.Expose the AI endpoint via an unencrypted HTTP binding for maximum performance.

C.Store all AI model weights and endpoint keys in public GitHub repositories for CI/CD access.

D.Configure a shared access signature (SAS) token with a 10-year expiration period.

E.Assign the appropriate Azure RBAC role to the application's managed identity on the AI service.

AnswersA, E

Disabling public network access removes the internet-facing route to the Azure AI resource, while a private endpoint assigns it a private IP inside your virtual network. Together they satisfy the policy's isolation requirement, forcing all traffic through your VNet rather than the public internet.

Why this answer

Option A is correct because disabling public network access on the Azure AI service resource and configuring a private endpoint ensures the endpoint is reachable only through a private IP address inside the virtual network, satisfying the requirement to remove public internet exposure. Option E is correct because assigning the appropriate Azure RBAC role (for example, Cognitive Services User or equivalent) to the application's managed identity on the AI service enables token-based, keyless authentication via Microsoft Entra ID, which is exactly how secure managed identities are used for API requests. Option B is wrong because an unencrypted HTTP binding violates the security requirement and offers no managed identity authentication.

Option C is wrong because storing model weights and endpoint keys in public GitHub repositories exposes secrets and is a severe security violation. Option D is wrong because a long-lived SAS token is a shared secret credential, not a managed identity, and a 10-year expiration creates an unacceptable security risk.

Exam trap

AI-200 often tests the misconception that a SAS token or API key rotation is equivalent to managed-identity authentication, when the exam explicitly requires keyless Entra ID access plus network isolation.

Full explanation →

380

MCQeasy

Your company stores product catalog items in Azure Cosmos DB for NoSQL and needs to implement vector search for recommendation capabilities. Which indexing policy property must you add to enable vector indexing on a container?

A.compositeIndexes

B.vectorIndexes

C.spatialIndexes

D.fullTextIndexes

AnswerB

The vectorIndexes property in the container's indexing policy defines vector paths, types, and similarity metrics, which Cosmos DB for NoSQL requires before it will index and serve vector search queries. Omitting it leaves embeddings unindexed, so VectorDistance queries fail or scan.

Why this answer

Azure Cosmos DB for NoSQL requires a `vectorIndexes` array in the container's indexing policy to define vector indexing on vector-typed properties. Each entry specifies the vector path and the vector index type (flat, quantizedFlat, or diskANN). Without this property, vector search queries cannot be served efficiently or at all against the container.

Exam trap

AI-200 often tests confusion between indexing policy sub-properties, tricking candidates who pick `compositeIndexes` or `spatialIndexes` because they sound like advanced indexing features.

How to eliminate wrong answers

Option A is wrong because `compositeIndexes` defines multi-property composite indexes for ORDER BY and filter operations on scalar fields, not vector similarity indexing. Option C is wrong because `spatialIndexes` enables geospatial indexing for GeoJSON point/polygon data used with ST_DISTANCE and ST_WITHIN, unrelated to vector embeddings. Option D is wrong because `fullTextIndexes` (where available) supports full-text search on string fields via Lucene-style queries, not vector similarity search on float arrays.

Full explanation →

381

MCQeasy

You need to ensure that traffic between your Azure App Service hosting an AI wrapper and your Azure AI Search instance does not traverse the public internet. Which feature should you implement?

A.Enable Cross-Origin Resource Sharing (CORS) with a restricted origin list.

B.Enable TLS mutual authentication (mTLS) on the Azure AI Search service.

C.Configure a Private Endpoint for the Azure AI Search service and integrate your App Service with the virtual network.

D.Configure IP access control lists on the Azure AI Search firewall to allow only the App Service outbound IPs.

AnswerC

A Private Endpoint assigns Azure AI Search a private IP inside your virtual network, and App Service virtual network integration routes traffic over that private path. This keeps queries off the public internet, satisfying the stem's no-public-internet constraint.

Why this answer

Azure Private Endpoint provides private IP addresses from your VNet to securely connect to Azure AI Search, keeping traffic off the public internet.

Full explanation →

382

MCQeasy

You are configuring Azure Event Grid to send events to an Azure Logic App. Which built-in trigger should you use in your Logic App workflow to receive these events seamlessly?

A.When messages arrive in a Service Bus queue

B.When a resource event occurs (Azure Event Grid trigger)

C.When a blob is added or modified (V2)

D.When an HTTP request is received

AnswerB

The Event Grid trigger subscribes the Logic App to a topic and fires on each published event, using Event Grid's push delivery and built-in validation handshake. This satisfies seamless receipt without polling, unlike HTTP request or recurrence triggers.

Why this answer

The 'When a resource event occurs' trigger is the native Azure Event Grid trigger in Logic Apps, designed specifically to subscribe to Event Grid topics and system topics. It handles the Event Grid subscription handshake, event schema validation, and delivery automatically, so events published to Event Grid flow directly into the workflow without custom parsing. This is the seamless, first-party integration path for Event Grid-to-Logic App event delivery.

Exam trap

AI-200 often tests whether candidates confuse Event Grid's native Logic App trigger with generic HTTP or storage-specific triggers, so watch for options that sound like they receive events but actually poll a different service.

How to eliminate wrong answers

Option A is wrong because the Service Bus queue trigger consumes messages from a Service Bus queue, not Event Grid events, and would require an intermediary to bridge Event Grid to Service Bus. Option C is wrong because the 'When a blob is added or modified (V2)' trigger is an Azure Blob Storage trigger that polls/subscribes to blob storage events, not a generic Event Grid event receiver. Option D is wrong because the HTTP request trigger creates a manual request endpoint and does not automatically handle Event Grid subscription validation or event schema, requiring custom validation code.

Full explanation →

383

MCQeasy

You are setting up Azure Monitor alerts for an Azure AI Search service. You want an SMS message to be sent to the on-call engineer whenever the search query latency exceeds 500ms. What component of Azure Monitor links the metric alert to the SMS notification channel?

A.Azure Service Health

B.Log Analytics workspace

C.Action group

D.Diagnostic setting

AnswerC

An action group holds the notification actions, including SMS, and is referenced by the alert rule. When query latency exceeds 500ms, the metric alert fires and triggers the action group, which sends the SMS to the on-call engineer.

Why this answer

An action group in Azure Monitor defines the set of notifications and actions that fire when an alert rule is triggered. When you create a metric alert for search query latency, you attach an action group that contains the SMS receiver (phone number) for the on-call engineer. The action group is the binding layer between the alert rule's condition and the notification channel, so it is the correct component here.

Exam trap

AI-200 often tests whether candidates confuse the alert rule (the condition) with the action group (the notification/action binding), so the trap is picking a telemetry-routing or health service instead of the component that actually delivers the SMS.

How to eliminate wrong answers

Option A is wrong because Azure Service Health reports platform-wide outages, planned maintenance, and advisories for Azure services — it does not deliver metric-threshold notifications for your own resources. Option B is wrong because a Log Analytics workspace is a data store and query engine for logs and metrics; it can host log-based alerts but does not itself define SMS notification channels. Option D is wrong because a diagnostic setting routes resource telemetry (logs/metrics) to destinations such as Log Analytics, Storage, or Event Hubs — it does not send notifications to people.

Full explanation →

384

MCQhard

You are configuring TLS termination for an AI model API hosted in Azure Container Apps using a custom domain name. Where must you upload or configure the custom SSL certificate?

A.In the Container App custom domains settings using a Key Vault reference or uploaded certificate

B.In the Azure Container Registry webhook configuration

C.Inside the container image filesystem under /etc/ssl/certs

D.On the underlying Azure Container Instances node pool

AnswerA

Container Apps binds the custom domain's TLS certificate at the app's custom domains settings, accepting either an uploaded PFX or a Key Vault reference. Configuring it there satisfies the custom domain TLS termination requirement; Front Door or an App Service plan is not involved.

Why this answer

In Azure Container Apps, TLS termination for a custom domain is configured at the Container App (or its managed environment) level: you add the custom domain and bind a certificate, which can be a managed certificate or a certificate you upload or reference from Azure Key Vault. The certificate is associated with the app's ingress configuration, not with the container image or registry. This is where the platform terminates TLS before forwarding traffic to your container.

Exam trap

The trap here is conflating client-side certificate trust (certs inside the container) with platform-level inbound TLS termination, causing candidates to pick the container filesystem option.

How to eliminate wrong answers

Option B is wrong because Azure Container Registry webhooks are notification mechanisms for image push/delete events and have nothing to do with TLS certificates or ingress. Option C is wrong because placing certs in the container filesystem under /etc/ssl/certs only affects TLS the container initiates as a client; it does not configure the platform's inbound TLS termination for the custom domain. Option D is wrong because Container Apps does not expose or rely on an underlying ACI node pool for certificate configuration — that is a fabricated layer; Container Apps runs on a managed Kubernetes-based environment.

Full explanation →

385

Multi-Selectmedium

You are architecting an event-driven AI ingestion pipeline using Azure Event Hubs. Which TWO features or capabilities are native to Azure Event Hubs? (Choose two)

Select 2 answers

A.Automatic dead-letter queue routing after max delivery count

B.Apache Kafka protocol endpoint compatibility

C.Event Hubs Capture for automated data archiving into Azure Blob Storage

D.Webhook event schema subscription validation handshakes

E.AMQP 1.0 message session management for FIFO per session ID

AnswersB, C

Event Hubs exposes a Kafka-compatible endpoint on port 9093, so existing Kafka producers and consumers connect without code changes. This native protocol surface satisfies the ingestion requirement by letting Kafka-based AI pipelines publish directly into Event Hubs partitions.

Why this answer

Option B is correct because Azure Event Hubs natively exposes a Kafka-compatible endpoint (port 9093, SASL/PLAIN or SASL/OAUTHBEARER), letting existing Apache Kafka producers and consumers connect without code changes. Option C is correct because Event Hubs Capture is a built-in feature that automatically archives streaming data to Azure Blob Storage or Azure Data Lake Storage in Avro format based on a time or size window, with no custom consumer required. Option A is not native: dead-lettering after a max delivery count is a Service Bus queue/subscription behavior, not an Event Hubs feature (Event Hubs uses consumer offsets and checkpointing).

Option D is not native: webhook subscription validation handshakes belong to Event Grid event subscriptions, not Event Hubs. Option E is not native: AMQP 1.0 sessions with FIFO per session ID are a Service Bus messaging capability; Event Hubs provides partition-based ordering, not AMQP session management.

Exam trap

AI-200 often tests the confusion between Azure Event Hubs and Azure Service Bus features, such as dead-lettering, sessions, and transactions, which are not native to Event Hubs.

Full explanation →

386

MCQhard

You are auditing an Azure AI solution for security compliance. You discover that developers have been hardcoding storage account connection strings in source code repositories. You need to remediate this immediately by migrating secrets to Azure Key Vault and ensuring your Python application retrieves them securely at runtime using a managed identity. Which Python library and credential class should your code use?

A.pyodbc with direct ODBC connection strings containing embedded passwords

B.azure-storage-blob with StorageSharedKeyCredential initialized with plain-text keys

C.azure-identity package with DefaultAzureCredential and azure-keyvault-secrets

D.requests library making direct REST calls with master subscription keys

AnswerC

The azure-identity package's DefaultAzureCredential authenticates the Python application to Key Vault via the managed identity, eliminating hardcoded connection strings. Combined with azure-keyvault-secrets, SecretClient retrieves secrets at runtime, satisfying the requirement to remove credentials from source code and authenticate without stored passwords.

Why this answer

The azure-identity package with DefaultAzureCredential combined with azure-keyvault-secrets is the correct approach: DefaultAzureCredential automatically chains managed identity, environment credentials, and developer credentials, so the app authenticates to Key Vault without hardcoded secrets, then retrieves the storage connection string at runtime. This eliminates secrets from source code and supports passwordless authentication. It is the Microsoft-recommended pattern for secure secret retrieval in Python.

Exam trap

AI-200 often tests whether candidates pick a credential class that still requires a plain-text key (like StorageSharedKeyCredential) instead of the passwordless DefaultAzureCredential plus Key Vault pattern.

How to eliminate wrong answers

Option A is wrong because pyodbc with embedded passwords in ODBC connection strings perpetuates the exact hardcoding problem being remediated and does not use managed identity or Key Vault. Option B is wrong because StorageSharedKeyCredential requires a plain-text account key, which is itself a secret that must be stored and rotated; it does not solve the hardcoding issue and bypasses Key Vault. Option D is wrong because direct REST calls with master subscription keys embed privileged credentials in code and do not use managed identity, Key Vault, or the azure-identity credential chain.

Full explanation →

387

Multi-Selectmedium

When troubleshooting a Python AI application integrated with Application Insights, you want to ensure comprehensive error tracking and telemetry collection. Which TWO of the following SDK practices should you implement? (Choose two)

Select 2 answers

A.Disable the Application Insights telemetry client entirely in production to save bandwidth.

B.Wrap unhandled exception handling with telemetry_client.track_exception() to capture stack traces.

C.Route all application logs exclusively to local text files on ephemeral container storage.

D.Explicitly call telemetry_client.flush() before application exit to ensure buffered items are transmitted.

E.Store plain-text passwords in telemetry custom dimensions.

AnswersB, D

Wrapping unhandled exceptions with `telemetry_client.track_exception()` captures full stack traces and exception details, satisfying the stem's requirement for comprehensive error tracking. Unlike generic logging, this method records the exception type, message and traceback as structured telemetry in Application Insights, enabling precise failure diagnosis across the Python AI application.

Why this answer

Option B is correct because telemetry_client.track_exception() explicitly records exception details, including the exception type, message, and stack trace, into Application Insights, which is essential for diagnosing unhandled errors in a Python AI application. Option D is correct because the Application Insights SDK buffers telemetry and sends it asynchronously; calling telemetry_client.flush() before the process exits ensures buffered items are transmitted rather than lost, which is critical in short-lived or containerized workloads. Option A is wrong because disabling the telemetry client in production eliminates the error tracking and telemetry collection the scenario requires.

Option C is wrong because routing logs only to local text files on ephemeral container storage means they are lost when the container is recycled and never reach Application Insights. Option E is wrong because storing plain-text passwords in custom dimensions exposes secrets in telemetry data and violates security best practices.

Exam trap

AI-200 often tests the misconception that telemetry is sent immediately and reliably; candidates forget that the SDK buffers telemetry and that flush() is required on exit, and they may also overlook that track_exception() is the correct API for capturing stack traces rather than relying on default logging.

Full explanation →

388

Multi-Selecthard

You are deploying a containerized AI model to Azure Container Apps. The model requires a persistent volume to store intermediate results and a secret to access an external API. You need to configure the container app to meet these requirements. Which two actions should you perform? (Choose two.)

Select 2 answers

A.Mount an Azure Blob Storage container as a file system using the BlobFuse driver.

B.Use a Kubernetes PersistentVolumeClaim (PVC) to provide persistent storage.

C.Embed the API secret in the container image as a build argument.

D.Store the API secret as a container app secret and reference it in an environment variable.

E.Create an Azure Files share and mount it as a volume in the container app.

AnswersD, E

Azure Container Apps allows you to define secrets at the application level. These secrets can be referenced in environment variables, which the container can read at runtime. This securely provides the API secret without hardcoding it in the image or configuration files. It is the recommended approach for managing sensitive data.

Why this answer

To provide persistent storage, you should create an Azure Files share and mount it as a volume in the container app. For the secret, you should store it as a container app secret and reference it in an environment variable. These actions meet the requirements securely and using native Azure Container Apps features.

Exam trap

The trap here is assuming that Kubernetes-native constructs like PVCs or alternative storage drivers like BlobFuse are supported, when Azure Container Apps has its own abstractions for storage and secrets.

Full explanation →

389

MCQmedium

Your AI application is hosted on Azure App Service and connects to Azure Cosmos DB and Azure OpenAI. You want to ensure that if credentials or connection strings ever leak, they cannot be used from unauthorized networks. Which feature should you implement?

A.Disabling managed identities across all application components

B.IP firewall rules and virtual network service rules on the backend services restricting access to App Service

C.Configuring Azure Front Door with SSL offloading only

D.Enabling public anonymous access with client-side rate limiting

AnswerB

IP firewall rules and virtual network service rules on Cosmos DB and Azure OpenAI restrict backend access to traffic originating from the App Service's outbound addresses or delegated subnet. Even if credentials leak, requests from unauthorised networks are rejected at the service boundary.

Why this answer

To prevent leaked credentials from being used from unauthorized networks, you should implement IP firewall rules and virtual network service rules on the backend services (Azure Cosmos DB and Azure OpenAI) to restrict access to only the App Service's outbound IP addresses or its virtual network. This ensures that even if credentials leak, they cannot be used from outside the allowed network.

Exam trap

AI-200 often tests network security controls. Candidates might focus on authentication or front-end security, but the question specifically asks about restricting access from unauthorized networks, which is achieved via IP firewall and virtual network rules.

How to eliminate wrong answers

Option A is wrong because disabling managed identities would remove a secure authentication method and is not a security best practice. Option C is wrong because Azure Front Door with SSL offloading only handles incoming traffic to the app; it does not restrict access to backend services based on network. Option D is wrong because enabling public anonymous access with client-side rate limiting is insecure and does not prevent unauthorized network access.

Full explanation →

390

MCQhard

An enterprise deployment of Azure OpenAI requires data encryption using a key that your security team fully manages and controls in Azure Key Vault. What must you configure?

A.Store the API keys in Azure Key Vault and enable automatic rotation every 7 days.

B.Configure Customer-Managed Keys (CMK) using an Azure Key Vault key with soft-delete and purge protection enabled, linked via a managed identity.

C.Configure infrastructure encryption at rest using a Microsoft-managed default key.

D.Enable Always Encrypted on the Azure OpenAI resource configuration plane.

AnswerB

Customer-Managed Keys wrap the data encryption key with a key your team owns in Azure Key Vault, so Microsoft cannot access it. Soft-delete and purge protection prevent irreversible key loss, and the managed identity grants Azure OpenAI secure access without storing credentials.

Why this answer

Customer-Managed Keys (CMK) let you encrypt Azure OpenAI data with a key you own in Azure Key Vault, and the resource accesses it via a managed identity. Soft-delete and purge protection must be enabled on the vault so the key cannot be permanently destroyed, which would render the data unrecoverable. This is the only option that gives the security team full control of the key lifecycle.

Exam trap

AI-200 often tests the misconception that storing API keys in Key Vault equals customer-managed encryption — candidates confuse secret management with CMK data encryption.

How to eliminate wrong answers

Option A is wrong because storing API keys in Key Vault is secret management, not data encryption — it does not make the security team the owner of the encryption key. Option C is wrong because Microsoft-managed keys mean Microsoft controls the key lifecycle, which contradicts the requirement for customer control. Option D is wrong because Always Encrypted is a SQL Server/Azure SQL feature and does not apply to the Azure OpenAI resource configuration plane.

Full explanation →

391

MCQhard

You are designing a high-throughput RAG pipeline where documents are continuously ingested and queried. You choose Azure Cosmos DB for NoSQL as your vector store. How does Cosmos DB handle vector indexing updates when new documents are inserted?

A.Vector indexes are updated asynchronously in the background by the database engine

B.You must manually trigger an index rebuild stored procedure every hour

C.Vector search is completely unavailable until the entire collection is re-indexed from scratch

D.New documents cannot be queried using VectorDistance until the container is restarted

AnswerA

Cosmos DB's vector index is maintained by the database engine without blocking writes, so inserts return quickly while index updates propagate in the background. This asynchronous behaviour satisfies the continuous-ingestion, high-throughput constraint in the stem.

Why this answer

Azure Cosmos DB for NoSQL automatically updates vector indexes asynchronously in the background when new documents are inserted. This means that after insertion, there may be a slight delay before the new vectors are indexed and available for vector search queries. The database engine handles the indexing without manual intervention.

Exam trap

AI-200 often tests the asynchronous nature of vector indexing in Cosmos DB. Candidates might think indexing is synchronous or requires manual intervention, but it's automatic and asynchronous.

How to eliminate wrong answers

Option B is wrong because you do not need to manually trigger an index rebuild; Cosmos DB manages indexing automatically. Option C is wrong because vector search remains available for existing documents; only the new documents are not immediately searchable until indexed. Option D is wrong because new documents can be queried using VectorDistance once they are indexed; a container restart is not required.

Full explanation →

392

MCQeasy

Your development team needs to store API keys and connection strings for an Azure Cognitive Search service securely without embedding them in the source code. Where should you store these secrets?

A.An Azure Storage Table with public read permissions

B.An environment variable in the application's appsettings.json file

C.Azure Key Vault

D.The Azure AI Studio model deployment configuration metadata

AnswerC

Azure Key Vault stores secrets such as API keys and connection strings in a hardened, access-controlled vault, letting applications retrieve them at runtime via managed identities instead of hard-coding them. This satisfies the stem's constraint of keeping credentials out of source code.

Why this answer

Azure Key Vault is the dedicated Azure service for storing and tightly controlling access to secrets, keys, and certificates. Storing API keys and connection strings there keeps them out of source code and enables RBAC, auditing, and managed identity access.

Exam trap

AI-200 often tests whether candidates confuse configuration management (appsettings.json, environment variables) with secret management, leading them to pick a file-based option that still exposes credentials.

How to eliminate wrong answers

Option A is wrong because an Azure Storage Table with public read permissions exposes secrets to anyone with the URL, a severe security violation. Option B is wrong because appsettings.json is source-controlled configuration and embedding secrets there leaks them into repositories and build artifacts. Option D is wrong because AI Studio deployment metadata is not a secrets store and does not provide access control or auditing for credentials.

Full explanation →

393

MCQmedium

You are developing an enterprise retrieval-augmented generation (RAG) application using Azure AI Search. You need to configure a vector index to store dense vector embeddings alongside traditional text fields. Which property within the Azure AI Search index definition must be explicitly configured with a vector search profile to enable HNSW (Hierarchical Navigable Small World) algorithm indexing?

A.vectorIndexKind

B.compressionMethod

C.vectorSearchProfile

D.similarityFunction

AnswerC

The `vectorSearchProfile` property on a vector field binds that field to a named profile in the index's `vectorSearch` configuration, where the HNSW algorithm and its parameters are defined. Without this assignment, Azure AI Search cannot apply HNSW indexing to the embeddings, so the field must reference the profile explicitly.

Why this answer

In an Azure AI Search index, the vectorSearchProfile property on a vector field binds that field to a named profile defined in the index's vectorSearch configuration. The profile in turn references an algorithm configuration (for example, an HNSW parameters object) and optionally a compression method, so setting vectorSearchProfile is what actually activates HNSW indexing for the field.

Exam trap

AI-200 often tests whether candidates know that the field-level vectorSearchProfile is the binding point, while algorithm parameters (HNSW) and compression live in the profile — so options like vectorIndexKind or similarityFunction sound authoritative but are not the enabling property.

How to eliminate wrong answers

Option A is wrong because vectorIndexKind is not a valid Azure AI Search index property — the algorithm is selected through the algorithm configuration referenced by the profile, not a 'kind' field. Option B is wrong because compressionMethod is a property of a vector search profile (used for scalar or binary quantization), not the field-level property that enables HNSW. Option D is wrong because similarityFunction is a legacy/related concept for scoring (cosine, dotProduct, euclidean) and does not itself wire a field to an HNSW algorithm configuration.

Full explanation →

394

MCQeasy

A team member needs read-only access to view AI model deployment metrics in Azure Monitor but should not be able to change any resource settings. Which built-in role should you assign?

A.Reader

B.Log Analytics Reader

C.Monitoring Reader

D.Contributor

AnswerC

Monitoring Reader grants read-only access to monitoring data and metrics across Azure Monitor without permitting changes to resource settings. It satisfies the least-privilege requirement, unlike Contributor or Owner, which would allow configuration modifications the team member must not perform.

Why this answer

The 'Monitoring Reader' role provides sufficient permissions to view all monitoring data, including metrics and logs, without allowing modifications.

Full explanation →

395

MCQmedium

You are evaluating Cosmos DB for NoSQL vs. Azure AI Search for a vector search application. Your application requires strict ACID compliance for metadata updates along with vector search. Which should you choose and why?

A.Cosmos DB because it is the only service that supports vectors.

B.Cosmos DB because it supports document-level ACID transactions.

C.Azure AI Search because it supports better hybrid search.

D.Azure AI Search because it uses HNSW for faster searches.

AnswerB

Cosmos DB for NoSQL provides native transactional guarantees within a single logical partition, satisfying the strict ACID requirement for metadata updates. Its integrated vector indexing and search capability handles embeddings in the same store, avoiding cross-service consistency gaps that Azure AI Search alone cannot close.

Why this answer

Cosmos DB for NoSQL supports document-level ACID transactions via the transactional batch API, ensuring metadata updates are atomic and consistent. When the requirement combines strict ACID compliance for metadata with vector search, Cosmos DB is the correct choice because Azure AI Search does not provide ACID transactional guarantees for document updates. This aligns the service's transactional model with the application's consistency requirement.

Exam trap

AI-200 often tests the trade-off between search richness (Azure AI Search) and transactional consistency (Cosmos DB), luring candidates toward Azure AI Search for its hybrid search and HNSW speed when the requirement explicitly demands ACID.

How to eliminate wrong answers

Option A is wrong because Azure AI Search also supports vectors, so Cosmos DB is not the only service with vector support—the reason to choose Cosmos DB is ACID, not exclusivity. Option C is wrong because hybrid search quality is not the stated requirement, and Azure AI Search lacks the ACID transaction guarantee the application needs. Option D is wrong because HNSW is used by Azure AI Search for fast approximate nearest neighbor search, but speed is not the requirement; ACID compliance is, and HNSW does not provide transactions.

Full explanation →

396

Multi-Selecthard

You are configuring authentication and authorization across Azure messaging and eventing services. Which THREE statements regarding security features are correct? (Choose three)

Select 3 answers

A.Event Grid custom topics require SQL database credentials for publisher authentication.

B.Shared Access Signature (SAS) tokens can be generated with specific permissions and expiration times.

C.Azure Service Bus and Event Hubs support Microsoft Entra ID RBAC for data plane access.

D.Azure Event Grid webhook subscriptions support Managed Identity authentication for secure target invocation.

E.Azure Service Bus queues require public anonymous access to be enabled for client SDK connections.

AnswersB, C, D

SAS tokens are issued against a namespace, entity or policy with explicitly scoped claims such as Send or Listen, plus a defined expiry. That granular, time-bound credential model satisfies the requirement for delegated, revocable access without exposing primary keys.

Why this answer

Option B is correct because SAS tokens for Service Bus, Event Hubs, and Storage are constructed with a signed resource URI, key name, expiry, and explicit permissions (for example Send, Listen, Manage), allowing least-privilege, time-bound access. Option C is correct because Service Bus and Event Hubs both expose data-plane RBAC roles such as Azure Service Bus Data Owner/Sender/Receiver and Event Hubs Data Owner/Sender/Receiver, letting Microsoft Entra ID identities authenticate without embedding SAS keys. Option D is correct because Event Grid webhook and Azure Function/Service Bus/Event Hubs subscription targets can use a system-assigned or user-assigned managed identity, with the target validating the Entra-issued token, avoiding secrets in the subscription.

Option A is wrong because Event Grid custom topics authenticate publishers with SAS keys or Microsoft Entra ID, not SQL database credentials. Option E is wrong because Service Bus queues are accessed via SAS or Entra ID over AMQP; anonymous public access is not required and should not be enabled.

Exam trap

AI-200 often tests the misconception that Azure messaging services require anonymous public access or database credentials, when in fact they use SAS tokens or Microsoft Entra ID RBAC for secure authentication.

Full explanation →

397

Multi-Selectmedium

When configuring vector search in Azure Cosmos DB for NoSQL, which TWO steps are required to prepare a container for vector search before inserting documents? (Choose two)

Select 2 answers

A.Define the vectorEmbeddingPolicy at container creation or update

B.Define vectorIndexes within the indexingPolicy

C.Mount an NFS network share for vector file storage

D.Install the pgvector extension on the container

E.Create a relational foreign key constraint to Azure SQL

AnswersA, B

Defining the vectorEmbeddingPolicy at container creation or update declares the vector properties, dimensions, data type and distance function that Cosmos DB's indexing engine requires. Without this policy, the container cannot interpret or index vector fields, so the stem's requirement to prepare the container before inserting documents is satisfied.

Why this answer

Option A is correct because Azure Cosmos DB for NoSQL requires a vectorEmbeddingPolicy on the container to declare the vector properties, including the path to the vector field, the data type (e.g., float32), dimensions, and distance function (cosine, dotproduct, or euclidean) before vectors can be stored and queried. Option B is correct because you must also define vectorIndexes inside the container's indexingPolicy, specifying the vector path and index type (flat, quantizedFlat, or diskANN), so the vector data is actually indexed and searchable. Options C, D, and E are incorrect: NFS shares, the pgvector extension, and relational foreign keys belong to other systems (file storage, PostgreSQL, and relational databases respectively) and are not part of Cosmos DB for NoSQL vector search configuration.

Exam trap

AI-200 often tests the misconception that vector search in Cosmos DB requires external extensions or relational features, when in fact it is natively supported through container policies.

Full explanation →

398

MCQeasy

Which Azure feature allows you to scan images in your registry for vulnerabilities before deploying them to your production cluster?

A.Microsoft Defender for Containers.

B.Azure Monitor.

C.Azure Key Vault.

D.Azure Policy.

AnswerA

Microsoft Defender for Containers scans images stored in Azure Container Registry for known vulnerabilities, surfacing findings before deployment. This satisfies the stem's pre-deployment scanning requirement, unlike registry RBAC or geo-replication, which govern access and availability rather than vulnerability detection.

Why this answer

Microsoft Defender for Containers is the Azure service that provides vulnerability scanning for container images stored in Azure Container Registry (ACR) and other registries. It automatically scans images on push and continuously monitors for new vulnerabilities, giving you a security assessment before deployment. This aligns with the question's requirement to scan images in your registry for vulnerabilities.

Exam trap

AI-200 often tests the distinction between security scanning (Defender for Containers) and policy enforcement (Azure Policy) or monitoring (Azure Monitor), so candidates may incorrectly choose Azure Policy because it can block deployments, but it does not perform vulnerability scanning.

How to eliminate wrong answers

Option B is wrong because Azure Monitor is a monitoring and observability service that collects metrics and logs; it does not perform vulnerability scanning of container images. Option C is wrong because Azure Key Vault is used for securely storing and managing secrets, keys, and certificates; it has no image scanning capability. Option D is wrong because Azure Policy is used to enforce organizational standards and assess compliance at scale; while it can audit or deny deployments based on conditions, it does not scan images for vulnerabilities.

Full explanation →

399

MCQmedium

You are configuring vector indexing in Azure Cosmos DB for MongoDB (vCore). You need to choose an indexing type for your vector property to balance query performance and recall accuracy for high-dimensional data. Which vector index type should you select for approximate nearest neighbor (ANN) search?

A.FULLTEXT index

B.HNSW (Hierarchical Navigable Small World)

C.B-Tree index

D.HASH index

AnswerB

HNSW builds a hierarchical proximity graph, giving logarithmic-complexity approximate nearest neighbour search with high recall on high-dimensional vectors. This satisfies the balance requirement, outperforming IVF and flat indexes on the recall-latency trade-off Cosmos DB for MongoDB (vCore) exposes.

Why this answer

HNSW (Hierarchical Navigable Small World) is a graph-based approximate nearest neighbor algorithm that builds a multi-layer navigable graph, delivering high recall with low latency for high-dimensional vectors. In Azure Cosmos DB for MongoDB vCore, HNSW is the supported vector index type for ANN search, and it is the recommended choice when you need to balance query performance and recall accuracy. FULLTEXT, B-Tree, and HASH indexes are not designed for vector similarity search and cannot perform ANN queries.

Exam trap

The trap here is confusing traditional database index types (B-Tree, HASH, FULLTEXT) with vector index types; candidates who have not worked with vector search may pick B-Tree or FULLTEXT because they are familiar, but only HNSW supports ANN in Cosmos DB for MongoDB vCore.

How to eliminate wrong answers

Option A is wrong because a FULLTEXT index performs lexical token-based text search (inverted index), not vector similarity; it cannot compute cosine or Euclidean distance between embeddings. Option C is wrong because a B-Tree index supports range and equality queries on scalar values, not high-dimensional vector proximity search. Option D is wrong because a HASH index supports exact-match equality lookups only; it has no notion of nearest neighbor or distance ranking, so it cannot perform ANN search.

Full explanation →

400

MCQhard

You are troubleshooting a performance issue where an Azure AI Search indexer fails to complete within the scheduled execution window when processing large PDF documents. What is the most effective configuration change to resolve the timeout issue?

A.Configure the indexer maxRunTime property and scale out search units or adjust batch size

B.Convert all vector fields to Edm.String

C.Switch the search service to the Free tier

D.Delete all semantic configurations from the index

AnswerA

The maxRunTime property extends or caps indexer execution, while scaling out search units and tuning batch size raise throughput so large PDFs finish within the window. Together these address the scheduled-window timeout constraint directly, unlike enrichment or skillset changes.

Why this answer

Indexer timeouts on large PDFs are typically caused by the indexer exceeding the scheduled run window while skillset enrichment and document cracking proceed slowly. Increasing maxRunTime extends the allowed execution window, and scaling out search units (or reducing batch size) increases throughput so the indexer completes within the schedule. These are the documented levers for resolving indexer timeout issues in Azure AI Search.

Exam trap

AI-200 often tests whether candidates confuse query-time features (semantic ranker, scoring profiles) with indexer-time performance controls, tempting them to remove semantic configs instead of tuning maxRunTime and scaling.

How to eliminate wrong answers

Option B is wrong because converting vector fields to Edm.String destroys the vector representation and breaks vector search entirely; it does not address indexer runtime. Option C is wrong because the Free tier has the lowest throughput and no scaling, which would worsen timeouts rather than resolve them. Option D is wrong because semantic configurations affect query-time ranking, not indexer execution time, and removing them provides no performance benefit to the indexing pipeline.

Full explanation →

401

MCQhard

You are configuring geo-disaster recovery for an Azure Service Bus Premium namespace containing critical financial transactions. A regional outage occurs. After initiating a failover to the secondary region, what happens to the alias pointing to the namespace?

A.The secondary namespace remains in Read-Only mode until manually unlocked.

B.The alias becomes invalid, and you must deploy a new Service Bus namespace from scratch.

C.Unreplicated messages in the primary queue are automatically migrated in real-time.

D.The alias automatically points to the secondary namespace, and pairing is broken.

AnswerD

Initiating a geo-failover repoints the alias to the secondary namespace automatically, and the existing pairing is severed. This satisfies the stem's requirement for continued routing during a regional outage, since the alias remains the stable connection string endpoint clients use without reconfiguration.

Why this answer

After a geo-disaster recovery failover in Azure Service Bus Premium, the alias automatically points to the secondary namespace and the pairing between primary and secondary is broken. The alias is a stable connection string endpoint that clients use, so applications do not need to change connection strings; however, the former primary becomes unusable until it is re-paired. This is the documented behavior of Service Bus Geo-DR failover.

Exam trap

AI-200 often tests whether candidates believe Geo-DR replicates messages (it does not—only metadata) or that the alias becomes invalid after failover (it automatically redirects to the secondary).

How to eliminate wrong answers

Option A is wrong because the secondary namespace becomes the active namespace after failover and is not left in a read-only locked state; it accepts both reads and writes once failover completes. Option B is wrong because the alias remains valid and automatically redirects to the secondary namespace; you do not need to deploy a new namespace from scratch. Option C is wrong because Service Bus Geo-DR replicates only metadata (queues, topics, subscriptions, filters, and policies), not message data; unreplicated messages in the primary are not migrated in real-time and are effectively lost or stranded in the old primary.

Full explanation →

402

Multi-Selectmedium

You are designing a vector search solution using Azure AI Search. Which THREE of the following are necessary steps to configure an index to support vector search?

Select 3 answers

A.Define a 'vectorSearch' configuration within the index schema.

B.Set the index to 'ReadOnly' mode.

C.Assign a 'vectorSearchProfile' to the vector-capable fields.

D.Ensure all vector fields are set to 'Edm.String'.

E.Define vector fields as type 'Collection(Edm.Single)'.

AnswersA, C, E

The vectorSearch object is the index-level container declaring algorithms and profiles; vector fields reference it through a profile. Without it, the service has no HNSW or exhaustive KNN configuration to build the vector index, so vector queries cannot be served.

Why this answer

Option A is correct because the index schema must include a 'vectorSearch' configuration block that declares the vector search algorithms (e.g., HNSW or exhaustive KNN) and the profiles used by the index. Option C is correct because each vector field must reference a 'vectorSearchProfile' that ties the field to a specific algorithm and vectorizer configuration defined in the 'vectorSearch' section. Option E is correct because Azure AI Search represents vector embeddings as 'Collection(Edm.Single)', a collection of single-precision floats, which is the required data type for vector fields.

Option B is incorrect because setting the index to 'ReadOnly' mode is unrelated to vector search configuration and would only prevent updates to the index. Option D is incorrect because 'Edm.String' is used for text fields, not vector fields, and would not store the numeric embedding arrays required for vector search.

Exam trap

AI-200 often tests whether candidates conflate the three distinct schema artifacts — 'vectorSearch' config, 'vectorSearchProfile', and the 'Collection(Edm.Single)' field type — with unrelated index settings like read-only mode or string field types, so picking 'Edm.String' or a permissions flag instead of the numeric collection type is the classic wrong-answer trap.

Full explanation →

403

MCQmedium

You are querying an Azure Cosmos DB for NoSQL container using vector search. You execute a query using the VectorDistance() system function. Which query structure is required to properly execute this vector search?

A.SELECT TOP 10 c.id FROM c WHERE VectorDistance(c.vectorProp, [0.1, 0.2]) > 0.9

B.JOIN vectorIndex ON c.id = vectorIndex.id

C.SELECT TOP 10 c.id, VectorDistance(c.vectorProp, [0.1, 0.2]) AS score FROM c ORDER BY VectorDistance(c.vectorProp, [0.1, 0.2])

D.GROUP BY VectorDistance(c.vectorProp, [0.1, 0.2])

AnswerC

Vector search in Cosmos DB for NoSQL requires ORDER BY on the VectorDistance() function so results are ranked by similarity, combined with TOP to limit returned rows. The SELECT projects the score alongside the document id, satisfying the required query structure.

Why this answer

Cosmos DB for NoSQL vector search requires the VectorDistance() function to be used in both the SELECT clause (to return the score) and the ORDER BY clause (to rank results). The query must also use TOP N to limit results, as vector search in Cosmos DB requires a top-k pattern. This structure allows the query engine to use the vector index for efficient nearest-neighbor search.

Exam trap

The trap is assuming VectorDistance() can be used in a WHERE filter or that a JOIN is needed, when the correct pattern requires it in SELECT and ORDER BY with TOP N.

How to eliminate wrong answers

Option A is wrong because using VectorDistance() in a WHERE clause with a comparison does not leverage the vector index and does not follow the required top-k pattern; it also returns no similarity score. Option B is wrong because Cosmos DB does not support JOIN with a vector index; vector search is performed via the VectorDistance() function, not a join. Option D is wrong because GROUP BY on VectorDistance() is not a valid vector search pattern and does not rank or limit results.

Full explanation →

404

MCQmedium

You are deploying an AI model container to Azure Container Apps. The container requires persistent storage to cache downloaded Hugging Face model weights across container restarts. Which storage type should you attach to the Container App?

A.Azure Managed Disks (Premium SSD) direct attach

B.Azure Blob Storage FUSE driver

C.Azure Files mount via Container Apps storage configuration

D.Ephemeral emptyDir volume

AnswerC

Azure Files mounts an SMB or NFS share into the container's filesystem, so cached Hugging Face weights persist outside the container lifecycle and survive restarts and revisions. This directly satisfies the persistent storage constraint, unlike ephemeral container-local disk or replica-scoped temporary storage.

Why this answer

Azure Container Apps supports mounting Azure Files shares as persistent volumes through the storage configuration at the environment or app level. Azure Files is the only fully managed, SMB/NFS-based shared file system that Container Apps can mount natively, and it persists independently of the container replica lifecycle, making it ideal for caching model weights across restarts.

Exam trap

AI-200 often tests whether candidates assume Container Apps supports the same volume types as AKS (Managed Disks, Blob FUSE) — in reality only Azure Files is natively mountable.

How to eliminate wrong answers

Option A is wrong because Azure Managed Disks cannot be directly attached to Container Apps — they are block devices designed for VMs and AKS, not the Container Apps sandbox. Option B is wrong because the Blob FUSE driver is a Linux FUSE client typically used inside AKS or VMs; Container Apps does not natively mount Blob Storage via FUSE as a volume. Option D is wrong because an emptyDir volume is ephemeral and tied to the pod/replica lifetime, so it is wiped on restart and cannot cache weights persistently.

Full explanation →

405

MCQeasy

Your application emits custom events to an Azure Event Grid topic. You want to test your webhook endpoint locally during development without deploying your code to Azure. Which tool should you use to receive events directly from Event Grid?

A.Use Azure Bastion to connect your localhost to the Event Grid topic.

B.Deploy the Event Grid Viewer sample web app to an accessible public URL or use ngrok to tunnel your local port.

C.Configure a local SQL Server Express trigger.

D.Attach an Azure Service Bus queue directly as a local debugging breakpoint.

AnswerB

Event Grid requires a publicly reachable HTTPS webhook for delivery, so exposing the local port via ngrok tunnelling or a deployed viewer gives the topic a valid endpoint. This satisfies the constraint of receiving live events without deploying your own code to Azure.

Why this answer

Event Grid delivers events via HTTP POST to a webhook endpoint, so the endpoint must be reachable from the public internet. During local development, you either deploy the Event Grid Viewer sample to a publicly accessible URL or use ngrok to create a public tunnel that forwards to your localhost port. This lets Event Grid push events directly to your local debugging session without deploying your application to Azure.

Exam trap

AI-200 often tests whether candidates confuse network access tools (like Bastion) with event delivery mechanisms, or assume that local debugging requires deploying to Azure.

How to eliminate wrong answers

Option A is wrong because Azure Bastion provides RDP/SSH access to Azure VMs over a private network; it does not create a public webhook endpoint or tunnel Event Grid events to localhost. Option C is wrong because SQL Server Express triggers are database-level constructs and have no relationship to Event Grid event delivery. Option D is wrong because Service Bus queues are message brokers, not debugging breakpoints, and cannot be attached to a local development environment to receive Event Grid events.

Full explanation →

406

MCQeasy

You are deploying a custom PyTorch model container image to Azure Container Apps. The container needs to scale out based on HTTP concurrent requests. Which built-in scale rule type should you configure in Azure Container Apps?

A.azure-service-bus

B.cpu

C.tcp

D.http

AnswerD

The http scale rule scales replicas according to concurrent HTTP requests, which matches the stated trigger. Azure Container Apps evaluates this built-in rule against incoming request concurrency, adding or removing replicas to meet demand without custom KEDA configuration.

Why this answer

Azure Container Apps supports built-in KEDA-based scale rules, and the 'http' scale rule type scales based on concurrent HTTP requests. This is the correct choice for scaling a container that receives HTTP traffic and needs to handle concurrent requests.

Exam trap

AI-200 often tests whether candidates know the built-in scale rule types in Azure Container Apps — the trap is selecting 'cpu' because it's a common default, but the question specifically asks for scaling based on HTTP concurrent requests, which maps to the 'http' rule.

How to eliminate wrong answers

Option A is wrong because 'azure-service-bus' scales based on the number of messages in an Azure Service Bus queue or topic, not HTTP requests. Option B is wrong because 'cpu' scales based on CPU utilization percentage, which is a resource metric, not HTTP concurrency. Option C is wrong because 'tcp' scales based on concurrent TCP connections, which is a lower-level metric and not specific to HTTP request concurrency.

Full explanation →

407

MCQeasy

When designing a data layer architecture for an AI application using Azure AI Search, what is the primary role of an integrated vectorizer?

A.To execute full-text BM25 keyword matching alongside vector calculations.

B.To automatically convert raw source text fields into vector embeddings during indexing and queries without requiring external orchestration code.

C.To compress vector indexes using lossy compression algorithms to save disk storage.

D.To generate cryptographic hashes for document deduplication.

AnswerB

An integrated vectorizer is attached to index fields and query inputs, calling the embedding model automatically during indexing and at query time. This removes the need for external orchestration code to generate embeddings, satisfying the no-code embedding requirement in Azure AI Search.

Why this answer

An integrated vectorizer in Azure AI Search is a configuration that binds an embedding model (e.g., Azure OpenAI text-embedding-ada-002) to an index so that raw text fields are automatically converted into vector embeddings at both indexing time and query time. This eliminates the need for external orchestration code to call the embedding API, chunk text, and push vectors into the index.

Exam trap

AI-200 often tests whether candidates confuse the vectorizer (embedding generation) with the semantic ranker (reranking) or with quantization (compression), leading them to pick an unrelated feature.

How to eliminate wrong answers

Option A is wrong because BM25 keyword matching is handled by the search engine's text index independently of the vectorizer; the vectorizer's job is embedding generation, not lexical scoring. Option C is wrong because the vectorizer does not compress indexes — compression is handled by quantization features like Scalar or Binary Quantization. Option D is wrong because cryptographic hashing for deduplication is unrelated to embedding generation; the vectorizer produces semantic vectors, not hashes.

Full explanation →

408

MCQeasy

You want to set up an alert that notifies you whenever an Azure AI service resource is deleted or modified in your subscription. Which Azure feature should you use to capture these management-plane operations?

A.Azure Cost Management budget alert

B.Azure Monitor Activity Log alert

C.Azure Advisor recommendation alert

D.Application Insights availability test

AnswerB

Activity Log alerts capture management-plane operations such as resource deletion or modification across the subscription, which is exactly the control-plane scope the stem describes. Metric alerts and resource health cover performance or availability signals instead, so they cannot detect these administrative changes.

Why this answer

Azure Monitor Activity Log alerts capture subscription-level management-plane events such as resource creation, deletion, and modification, making them the correct choice for notifying on resource changes. Activity Log records control-plane operations across all Azure resources in a subscription. This is distinct from metric or log alerts, which target resource telemetry rather than management operations.

Exam trap

AI-200 often tests the confusion between control-plane (Activity Log) and data-plane (resource/diagnostic logs) monitoring, so candidates pick Application Insights or Advisor when the question is about resource lifecycle events.

How to eliminate wrong answers

Option A is wrong because Cost Management budget alerts only fire when spending crosses defined thresholds — they have no visibility into resource create/delete/modify events. Option C is wrong because Azure Advisor recommendation alerts notify on new Advisor recommendations (cost, security, reliability suggestions), not on management-plane operations. Option D is wrong because Application Insights availability tests are synthetic HTTP probes that measure endpoint uptime from external locations, not subscription-level resource changes.

Full explanation →

409

MCQhard

You are designing an event-driven AI document processing pipeline. Incoming PDF documents are uploaded to Azure Blob Storage, triggering an Event Grid event. The event triggers an Azure Function that downloads the PDF, processes it with Azure AI Document Intelligence, and saves results to Azure Cosmos DB. Under high load, duplicate events are occasionally received by the function, causing duplicate Cosmos DB records. How should you design the Azure Function to handle idempotency?

A.Implement idempotency in the Azure Function by checking if the document record already exists in Cosmos DB or using an upsert operation with a deterministic ID.

B.Set the Event Grid retry count to zero.

C.Deploy an Azure Service Bus queue in front of Blob Storage to serialize all requests into a single partition.

D.Configure Event Grid delivery mode to 'Exactly-Once' in the subscription settings.

AnswerA

Deterministic IDs derived from the document or an existence check before writing prevent duplicate Cosmos DB records when Event Grid redelivers events. Upsert with a stable key makes the write idempotent, satisfying the constraint that repeated processing of the same PDF must not create duplicates.

Why this answer

Idempotency in an at-least-once event pipeline is achieved by making the consumer's write operation idempotent — either by checking for an existing record before insert or by using an upsert with a deterministic ID derived from the event. This ensures duplicate Event Grid deliveries produce the same final state in Cosmos DB without creating duplicate records.

Exam trap

The trap is believing Event Grid offers an 'Exactly-Once' delivery mode or that disabling retries prevents duplicates — Event Grid is at-least-once by design, so idempotency must be implemented in the consumer.

How to eliminate wrong answers

Option B is wrong because setting Event Grid retry count to zero does not prevent duplicate deliveries — Event Grid is inherently at-least-once and duplicates can occur even without retries due to internal redelivery. Option C is wrong because inserting a Service Bus queue does not eliminate duplicates; Service Bus is also at-least-once and adds complexity without solving idempotency. Option D is wrong because Event Grid does not offer an 'Exactly-Once' delivery mode — this is a fictional setting; exactly-once is not a guarantee Event Grid provides.

Full explanation →

410

MCQeasy

You want to create a centralized dashboard in the Azure portal that displays custom AI model performance metrics alongside infrastructure CPU and memory metrics. Which Azure Monitor feature should you create?

A.Azure Workbook

B.Azure Service Bus queue

C.Azure Key Vault access policy

D.Azure Container Registry webhook

AnswerA

Azure Workbook combines multiple data sources, including custom metrics and platform metrics, into a single interactive report. It satisfies the stem's requirement to display AI model performance alongside infrastructure CPU and memory metrics in one centralised Azure portal dashboard.

Why this answer

Azure Workbook is the correct choice because it provides a flexible canvas for combining and visualizing data from multiple sources, including custom metrics from AI models and infrastructure metrics like CPU and memory. Workbooks allow you to create interactive reports and dashboards that can be shared across teams, making them ideal for centralized monitoring. They support parameters, charts, grids, and text, enabling a unified view of disparate telemetry.

Exam trap

AI-200 often tests the distinction between monitoring and visualization tools versus other Azure services that serve different purposes, such as messaging, security, or container management.

How to eliminate wrong answers

Option B is wrong because Azure Service Bus queue is a messaging service for decoupling applications, not a monitoring or dashboard tool. Option C is wrong because Azure Key Vault access policy controls permissions to secrets, keys, and certificates, not visualization of metrics. Option D is wrong because Azure Container Registry webhook triggers actions on container image events, not for displaying metrics.

Full explanation →

411

Multi-Selectmedium

When analyzing cost reports in Azure Cost Management for your machine learning and AI services, which TWO grouping or filtering options help identify spending anomalies? (Choose two)

Select 2 answers

A.Filter by Service Name (e.g., 'Cognitive Services' or 'Machine Learning') to track specific AI spend.

B.Group costs by Application Insights trace message text.

C.Group costs by virtual machine mouse device driver versions.

D.Filter by Azure DNS record TTL settings.

E.Group costs by Resource Group or Resource Name to pinpoint expensive workloads.

AnswersA, E

Filtering by Service Name isolates charges such as Cognitive Services or Machine Learning, removing unrelated subscription spend so an AI-specific cost spike becomes visible. This satisfies the stem's requirement for a filtering option that identifies spending anomalies in AI services.

Why this answer

Option A is correct because Azure Cost Management supports filtering by Service Name (the meter's service, such as 'Cognitive Services' or 'Machine Learning'), which isolates AI-related charges so anomalies in those specific services become visible against the rest of the bill. Option E is correct because grouping by Resource Group or Resource Name aggregates costs per workload, letting you pinpoint which specific ML/AI resource (for example, a GPU-enabled VM or an Azure Machine Learning workspace) is driving an unexpected spike. Options B, C, and D are incorrect because Application Insights trace message text, VM mouse device driver versions, and Azure DNS record TTL settings are not cost dimensions in Cost Management; they are telemetry, hardware, and DNS configuration data respectively, and none of them can be used to group or filter cost report data.

Exam trap

AI-200 often tests whether candidates recognize that Cost Management only groups/filters on real cost dimensions (service, resource, tag, meter) — options referencing log text, driver versions, or DNS TTL are distractors.

Full explanation →

412

MCQmedium

You are deploying an AI workload to Azure Container Apps. You need to ensure the container scales down to zero when there is no traffic. What should you configure?

A.Set maximum replicas to 0.

B.Enable the 'Always On' flag.

C.Set minimum replicas to 0.

D.Configure an external HTTP trigger.

AnswerC

Setting minimum replicas to zero permits the scale rule to reduce the revision to no running instances when traffic ceases, satisfying the scale-to-zero requirement. Container Apps then activates a replica on the next incoming request, so cold-start latency applies but idle compute cost is eliminated.

Why this answer

Azure Container Apps scales to zero when the minimum replica count is set to 0. This allows the platform to deprovision all replicas during periods of no traffic, eliminating compute cost, and scale back up when a request arrives (subject to the configured scale rules and HTTP ingress).

Exam trap

AI-200 often tests the min vs. max replica distinction, tricking candidates who pick 'maximum replicas to 0' or 'Always On' when the correct lever is minimum replicas.

How to eliminate wrong answers

Option A is wrong because maximum replicas defines the upper scaling bound; setting it to 0 would prevent any replicas from running and is not a valid or meaningful configuration for scale-to-zero. Option B is wrong because 'Always On' keeps at least one replica running, which is the opposite of scaling to zero. Option D is wrong because configuring an external HTTP trigger enables ingress and can drive scaling, but it does not by itself cause scale-to-zero — the minimum replica count must be 0.

Full explanation →

413

Multi-Selecthard

You are designing a data layer architecture for an enterprise AI assistant that requires high-performance vector search, structured filtering, and multi-tenant isolation. Which THREE design patterns should you consider? (Choose three)

Select 3 answers

A.Combining vector similarity with metadata filters to narrow search scope

B.Storing all tenant data in a single unindexed JSON blob without partition keys

C.Using tenant-specific partition keys or metadata filter tags for multi-tenant isolation

D.Hardcoding all user prompts directly into the search index schema

E.Implementing hybrid search to capture both exact keyword matches and conceptual similarities

AnswersA, C, E

Hybrid filtering applies metadata predicates alongside vector similarity, so tenant identifiers and structured attributes restrict the candidate set before or during nearest-neighbour search. This satisfies the stem's structured filtering and multi-tenant isolation requirements while preserving high-performance vector search across partitioned data.

Why this answer

Option A is correct because combining vector similarity with metadata filters (pre-filtering or post-filtering on structured attributes) narrows the candidate set, improving both relevance and latency for an AI assistant that needs structured filtering alongside semantic search. Option C is correct because tenant-specific partition keys or metadata filter tags enforce logical isolation in a shared vector index, ensuring queries only return a tenant's own data and satisfying multi-tenant isolation requirements. Option E is correct because hybrid search fuses dense vector similarity with sparse keyword matching (for example BM25 plus embeddings, often combined via reciprocal rank fusion), capturing both exact term matches and conceptual similarity for higher recall and precision.

Option B is wrong because an unindexed JSON blob with no partition keys destroys search performance and provides no tenant isolation. Option D is wrong because hardcoding user prompts into the index schema is brittle, non-scalable, and violates separation of data from schema design.

Exam trap

The trap is that 'single unindexed JSON blob' and 'hardcoding prompts' are obviously bad, but candidates sometimes hesitate on hybrid search, thinking vector search alone suffices — the exam expects you to recognize that enterprise assistants need both keyword and semantic retrieval.

Full explanation →

414

Multi-Selecteasy

Your organization requires that container images stored in Azure Container Registry (ACR) comply with security standards. Which TWO actions can you take to secure container images in ACR? (Choose two.)

Select 2 answers

A.Grant Contributor permissions to every external guest user

B.Store registry administrator credentials in public GitHub repositories for easy team access

C.Disable all network firewalls on the registry to allow unrestricted public pulling

D.Enable Microsoft Defender for Cloud vulnerability scanning for ACR registries

E.Enable content trust to ensure only signed container images are deployed

AnswersD, E

Microsoft Defender for Cloud scans ACR registries for vulnerabilities in pushed images, surfacing CVEs against your security baseline. Enabling it directly satisfies the requirement that stored container images comply with security standards, giving continuous assessment rather than build-time-only checks.

Why this answer

Option D is correct because enabling Microsoft Defender for Cloud's vulnerability scanning for ACR registries continuously scans images for known CVEs and provides remediation guidance, directly supporting image security compliance. Option E is correct because enabling content trust (Docker Content Trust) enforces image signing and verification, ensuring only trusted, signed images are pulled or deployed, which prevents tampered or unauthorized images from being used. Option A is wrong because granting Contributor permissions to every external guest user violates least-privilege and expands the attack surface rather than securing images.

Option B is wrong because storing registry administrator credentials in public GitHub repositories exposes secrets and enables unauthorized access. Option C is wrong because disabling network firewalls and allowing unrestricted public pulling removes network-level protections and increases exposure of the registry.

Exam trap

The trap is that candidates pick 'easy access' options (public GitHub, open firewalls, broad Contributor) thinking they improve collaboration, when the question asks for security controls — always favor least privilege, network isolation, and content integrity.

Full explanation →

415

Multi-Selecthard

When configuring vector search algorithms in Azure AI Search, you can tune several parameters associated with the Hierarchical Navigable Small World (HNSW) graph. Which THREE parameters are configurable within an HNSW algorithm profile?

Select 3 answers

A.efConstruction

B.bm25K1

C.chunkOverlapSize

D.efSearch

E.m

AnswersA, D, E

efConstruction controls the size of the dynamic candidate list during index construction, directly governing graph quality and build-time cost. It is one of the three tunable HNSW parameters in Azure AI Search, alongside m and efSearch, satisfying the stem's requirement for configurable HNSW profile settings.

Why this answer

In Azure AI Search, an HNSW algorithm profile exposes three tunable graph parameters: efConstruction (option A), which controls the size of the dynamic candidate list during index construction and thus the quality of the built graph; efSearch (option D), which controls the size of the candidate list at query time and trades recall against latency; and m (option E), which sets the number of bidirectional links created per node and governs graph connectivity and memory usage. These are exactly the parameters documented for the HNSW configuration object in Azure AI Search. Option B (bm25K1) is a parameter of the BM25 ranking function used for keyword relevance scoring, not vector search, and option C (chunkOverlapSize) relates to how documents are split during chunking in a skillset or integrated vectorization pipeline, not to the HNSW graph itself.

Exam trap

AI-200 often tests whether candidates can distinguish HNSW graph parameters (m, efConstruction, efSearch) from BM25 text-scoring parameters (k1, b) and chunking parameters (chunkSize, chunkOverlap).

Full explanation →

416

Multi-Selecthard

You are designing a secure MLOps pipeline using Azure Container Registry. Which THREE practices should you implement to secure your AI container images?

Select 3 answers

A.Disable role-based access control (RBAC) on the registry to simplify management

B.Use managed identities instead of admin credentials for registry authentication

C.Sign container images using Notation before pushing to ACR

D.Enable Microsoft Defender for Cloud vulnerability scanning on the ACR registry

E.Enable anonymous pull access for all public developers

AnswersB, C, D

Managed identities let the pipeline authenticate to Azure Container Registry without stored admin passwords, eliminating long-lived credentials that could be leaked. This directly satisfies the stem's constraint of securing AI container images within the MLOps pipeline.

Why this answer

Option B is correct because managed identities let Azure services (e.g., AKS, Azure ML) authenticate to ACR without storing admin username/password secrets, eliminating credential leakage and enabling least-privilege RBAC assignments. Option C is correct because signing images with Notation (Notary Project) and verifying signatures at deploy time ensures image integrity and provenance, preventing tampered or unauthorized images from running. Option D is correct because Microsoft Defender for Cloud's container registry scanning continuously detects OS and language-level CVEs in pushed images, so vulnerable images can be remediated before deployment.

Option A is wrong because disabling RBAC removes fine-grained access control and weakens registry security rather than simplifying it safely. Option E is wrong because anonymous pull access exposes images to anyone, violating the principle of least privilege and risking IP theft or supply-chain abuse.

Exam trap

AI-200 often tests whether candidates confuse 'simplify management' with 'improve security' — disabling RBAC or enabling anonymous pull sounds convenient but is a security anti-pattern.

Full explanation →

417

MCQeasy

Which Azure AI Search feature allows you to re-order search results using advanced machine learning models trained by Microsoft to dramatically improve semantic relevance?

A.BM25 Scoring

B.Fuzzy Search

C.Reciprocal Rank Fusion

D.Semantic Ranker

AnswerD

Semantic Ranker re-orders results using Microsoft's advanced machine learning models, satisfying the stem's requirement for dramatically improved semantic relevance. It reranks an initial result set, promoting contextually meaningful matches over keyword-only ordering. This directly addresses the need to re-order search results with Microsoft-trained models.

Why this answer

Semantic Ranker is the Azure AI Search feature that applies Microsoft's deep learning models (based on transformer/BERT-style architectures) to re-rank an initial BM25 result set, promoting results that are semantically relevant to the query rather than just lexically matching. It operates as an L2 ranking stage on top of the L1 retrieval results, using the query and document text to compute semantic relevance scores. This dramatically improves relevance for natural-language queries where keyword overlap is weak.

Exam trap

AI-200 often tests the distinction between the L1 lexical ranker (BM25) and the L2 ML-based re-ranker (Semantic Ranker), so candidates who see 'machine learning models trained by Microsoft' and pick BM25 or RRF get it wrong.

How to eliminate wrong answers

Option A is wrong because BM25 is the L1 lexical ranking algorithm (a probabilistic term-frequency/inverse-document-frequency scorer) that Semantic Ranker actually re-orders — it is not the ML-based re-ranker itself. Option B is wrong because fuzzy search only handles typos and approximate string matches via edit-distance logic; it does not perform semantic re-ranking. Option C is wrong because Reciprocal Rank Fusion is a technique for merging multiple ranked result lists (e.g., vector and keyword results in hybrid search) into one, not a Microsoft-trained semantic relevance model.

Full explanation →

418

MCQhard

You are optimizing query performance for an Azure AI Search index experiencing high query volumes with vector search. You need to scale out query processing capabilities without increasing index build time. Which action should you perform?

A.Rebuild the index using exhaustiveKnn

B.Increase the number of partition instances

C.Increase the number of search units by adding replica instances

D.Upgrade the search service from Standard to Basic tier

AnswerC

Adding replicas increases the search units available for query processing, distributing vector queries across more nodes. This scales out query throughput directly, satisfying the high query volume constraint, while leaving partitions untouched so index build time and index size remain unchanged.

Why this answer

In Azure AI Search, query processing capacity is scaled by adding replicas (search units), not partitions. Replicas host copies of the index and serve queries in parallel, so adding replicas increases query throughput without affecting index build time. Partitions, by contrast, affect index size and write/indexing throughput, so increasing them would lengthen index build time.

Exam trap

AI-200 often tests the distinction between scaling for query throughput (replicas) versus scaling for storage/indexing (partitions); candidates frequently confuse the two and pick partitions.

How to eliminate wrong answers

Option A is wrong because exhaustiveKnn forces a full brute-force scan of all vectors, which is slower and does not scale out query processing — it actually degrades performance. Option B is wrong because increasing partitions scales storage and indexing throughput, not query throughput, and it increases index build time. Option D is wrong because Basic tier is a lower tier than Standard and cannot support the same scale or vector search features; downgrading would reduce capacity.

Full explanation →

Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) (AI-200) — Questions 376–418