Courseiva

Microsoft Certified: Azure AI Cloud Developer Associate (AI-200) (AI-200) (AI-200) — Questions 151–225

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

Page 2

Page 3 of 6

Page 4
151
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

152
Multi-Selectmedium

You are securing an Azure AI Search service. Which THREE of the following actions are recommended for implementing a robust security posture? (Choose THREE)

Select 3 answers
A.Store all search index data in a public blob container for faster access.
B.Enable Private Endpoint access and disable public network access.
C.Use an Admin API key for all read-only client applications.
D.Enable Entra ID (formerly Azure AD) authentication to replace API keys.
E.Configure Azure Role-Based Access Control (RBAC) to manage data plane access.
AnswersB, D, E

A private endpoint gives the search service a private IP inside your virtual network, and disabling public network access removes internet exposure entirely. This satisfies the requirement to eliminate public attack surface for the service.

Why this answer

Option B is correct because enabling a Private Endpoint for Azure AI Search creates a private IP connection via Azure Private Link, and setting public network access to Disabled ensures the service is only reachable from within the virtual network, eliminating exposure to the public internet. Option D is correct because Entra ID (formerly Azure AD) authentication allows callers to be authenticated with identity tokens and assigned granular roles, removing the need to distribute and rotate static admin or query API keys that can be leaked. Option E is correct because Azure RBAC (for example, Search Service Contributor, Search Index Data Contributor, and Search Index Data Reader roles) governs data plane and control plane access through Entra ID identities, enabling least-privilege and auditable access management.

Option A is wrong because storing index data in a public blob container exposes sensitive content and is not how Azure AI Search stores or secures its indexes. Option C is wrong because admin API keys grant full control-plane rights (create, update, delete indexes) and should never be handed to read-only client applications; query keys or Entra ID-based read roles should be used instead.

Exam trap

AI-200 often tests whether candidates know that Admin API keys are over-privileged for read-only clients and that Entra ID RBAC plus Private Endpoints are the recommended modern security controls — candidates mistakenly pick API keys for convenience.

153
MCQhard

You are designing an AI architecture that stores vector embeddings in Azure Cosmos DB for NoSQL. You need to implement role-based access control (RBAC) so that specific application microservices can only execute read-only queries against the database without having permission to write or delete documents. How should you configure this?

A.Configure Azure Blob Storage RBAC permissions on the Cosmos DB container
B.Share the primary master master-key with all microservices
C.Create a custom SQL role definition with read-only data actions and assign it to the microservice's managed identity
D.Disable authentication on the Cosmos DB account during query execution
AnswerC

A custom SQL role definition scoped to read-only data actions, assigned to the microservice's managed identity, grants query access without write or delete permissions. This enforces least privilege for Microsoft Entra ID-backed authentication in Azure Cosmos DB for NoSQL.

Why this answer

Azure Cosmos DB for NoSQL has a native RBAC system built on SQL role definitions and role assignments. A custom role definition can be scoped to specific data-plane actions such as 'Microsoft.DocumentDB/databaseAccounts/readMetadata' and 'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/read', granting read-only access. Assigning that role to the microservice's managed identity enforces least privilege without exposing keys.

Exam trap

AI-200 often tests the misconception that Cosmos DB access control is done through Azure RBAC or shared keys, when data-plane read/write scoping actually requires SQL role definitions and role assignments.

How to eliminate wrong answers

Option A is wrong because Azure Blob Storage RBAC governs blob containers, not Cosmos DB data-plane operations, and cannot grant or restrict SQL query permissions. Option B is wrong because the primary master key grants full control-plane and data-plane access, so sharing it violates least privilege and cannot be scoped to read-only. Option D is wrong because disabling authentication removes all access control and exposes the account to anonymous access, which is never a valid RBAC configuration.

154
MCQmedium

You are configuring continuous deployment for an AI model container using Azure DevOps and Azure Container Registry (ACR). You need to ensure that when a new container image is pushed to ACR, an event triggers an automated webhook that notifies an Azure Function to run post-deployment validation tests. Which event type should you subscribe to in the ACR webhook configuration?

A.artifactDelete
B.chartPush
C.imagePush
D.quarantineStatusChange
AnswerC

imagePush fires whenever a new image or tag lands in the registry, matching the requirement for a push-triggered webhook. Other event types such as imageDelete or chartPush do not cover image publication, so subscribing to imagePush lets the Azure Function run validation immediately after deployment.

Why this answer

The imagePush event fires whenever a new container image or tag is pushed to the registry, which is exactly the trigger needed to invoke a webhook that notifies an Azure Function for post-deployment validation. ACR webhooks subscribe to specific event types, and imagePush is the canonical event for CI/CD pipelines reacting to new images.

Exam trap

AI-200 often tests whether candidates can distinguish ACR event types — imagePush is the obvious answer, but chartPush and quarantineStatusChange are plausible-sounding distractors that only apply to Helm charts or content-trust workflows.

How to eliminate wrong answers

Option A is wrong because artifactDelete fires when an artifact (image manifest or tag) is deleted, which is a cleanup event, not a deployment trigger. Option B is wrong because chartPush fires only for Helm chart pushes to an OCI-compliant registry, not for container image pushes. Option D is wrong because quarantineStatusChange fires when an image's quarantine status changes (used with content trust/Notary), which is unrelated to triggering deployment validation.

155
MCQmedium

Your enterprise AI system processes sensitive Personal Identifiable Information (PII). Compliance regulations require that audit logs capturing who accessed the AI endpoints must be retained immutably for 5 years without possibility of deletion. Where should you configure this immutability policy?

A.Azure Storage account container immutability policies with time-based retention
B.Azure Active Directory audit log retention configuration
C.Application Insights retention settings configured via the portal
D.Azure Key Vault soft-delete and purge protection
AnswerA

Container-level time-based retention policies in Azure Storage enforce WORM immutability, preventing modification or deletion for the defined period. Configuring a five-year retention period on the container holding the audit logs satisfies the compliance requirement for immutable, non-deletable records.

Why this answer

Azure Storage account container immutability policies with time-based retention (WORM — Write Once, Read Many) enforce that blobs cannot be modified or deleted for a specified retention period, and when locked, the policy cannot be removed even by account owners. This directly satisfies the requirement for immutable 5-year audit log retention. Audit logs written to an immutable container remain tamper-proof for the full retention window.

Exam trap

AI-200 often tests the distinction between retention (how long data is queryable) and immutability (data cannot be altered or deleted), and candidates frequently pick Entra ID or Application Insights retention settings because they sound like audit-log controls.

How to eliminate wrong answers

Option B is wrong because Azure AD (Entra ID) audit log retention is a diagnostic setting that controls how long logs are queryable in the portal — it does not provide immutability and logs can still be exported, altered, or purged by privileged users. Option C is wrong because Application Insights retention settings only control how long telemetry data remains queryable in Log Analytics; data is deletable and the setting is a query-window, not a legal hold. Option D is wrong because Key Vault soft-delete and purge protection apply to secrets, keys, and certificates — they protect cryptographic material from accidental deletion, not audit log immutability, and have no bearing on log retention.

156
MCQmedium

An enterprise application calls multiple Azure AI Language services. You need to trace requests across multiple distributed microservices to diagnose high latency issues. Which Azure Monitor capability should you implement?

A.Application Insights Distributed Tracing
B.Azure Advisor cost recommendations
C.Log Analytics metric alerts without instrumentation
D.Azure Network Watcher Connection Monitor
AnswerA

Application Insights Distributed Tracing correlates operations across microservices using a shared operation ID, exposing per-hop latency in the end-to-end transaction view. This satisfies the requirement to trace requests across distributed services and diagnose high latency.

Why this answer

Distributed tracing in Application Insights tracks requests across multiple service boundaries using W3C Trace Context headers.

157
MCQhard

Your team is using managed identities to connect an Azure App Service web app to an Azure OpenAI resource. The connection fails with a 403 Forbidden error. What is the most likely root cause?

A.The App Service must be bound to a custom domain before managed identities can issue bearer tokens.
B.The app service requires a client secret stored in Azure Key Vault for managed identity authentication.
C.The managed identity has not been granted the 'Cognitive Services OpenAI User' role on the Azure OpenAI resource.
D.System-assigned managed identities cannot authenticate against Azure AI PaaS endpoints.
AnswerC

Managed identity authentication succeeds at the token level, but authorisation fails because no role assignment grants data-plane access. Assigning 'Cognitive Services OpenAI User' on the Azure OpenAI resource supplies the missing permission, resolving the 403 Forbidden error.

Why this answer

A 403 Forbidden from Azure OpenAI when using a managed identity almost always means the identity authenticated successfully (otherwise you'd see 401) but lacks the required data-plane RBAC role. The 'Cognitive Services OpenAI User' role grants the necessary permissions to call the Azure OpenAI inference endpoints. Assigning this role to the App Service's managed identity on the Azure OpenAI resource resolves the 403.

Exam trap

AI-200 often tests the distinction between authentication (401) and authorization (403) failures, and candidates frequently pick answers that suggest managed identities don't work with PaaS services or that secrets are still required.

How to eliminate wrong answers

Option A is wrong because managed identities issue bearer tokens via the Instance Metadata Service (IMDS) regardless of custom domain bindings — domain configuration is unrelated to token issuance. Option B is wrong because managed identities are specifically designed to eliminate the need for client secrets; requiring a Key Vault secret contradicts the purpose of managed identity authentication. Option D is wrong because system-assigned managed identities fully support authentication to Azure AI PaaS endpoints, including Azure OpenAI, Cognitive Services, and Azure ML — this is a documented and recommended pattern.

158
MCQmedium

You are deploying an AI-powered document processing solution that uses Azure Functions to call Azure OpenAI. The Azure Functions app runs in a Consumption plan. You need to ensure that the function can authenticate to Azure OpenAI without storing any secrets in code or configuration. You want to use a managed identity. What should you do first?

A.Store the Azure OpenAI API key in Azure Key Vault and reference it from the function app settings using a Key Vault reference.
B.Create an application registration in Microsoft Entra ID and use its client secret to authenticate the function app to Azure OpenAI.
C.Enable a system-assigned managed identity on the Azure Functions app and grant it the Cognitive Services OpenAI User role on the Azure OpenAI resource.
D.Generate a shared access signature (SAS) token for the Azure OpenAI resource and pass it in the request header from the function.
AnswerC

Enabling a system-assigned managed identity on the Function App creates a service principal in Microsoft Entra ID. Assigning the Cognitive Services OpenAI User role to that identity on the Azure OpenAI resource grants the necessary permissions to call the service. This approach eliminates secrets and follows the principle of least privilege.

Why this answer

A system-assigned managed identity on the Azure Functions app allows it to authenticate to Azure OpenAI without any secrets. Granting the Cognitive Services OpenAI User role provides the necessary permissions. This is the recommended approach for secretless authentication in Azure.

Exam trap

The trap here is assuming that storing secrets in Key Vault is sufficient for a secretless solution, but the requirement explicitly prohibits storing secrets anywhere.

159
Multi-Selecthard

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

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

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

Why this answer

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

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

Exam trap

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

160
Multi-Selecteasy

Which THREE of the following are common reasons for a container image pull failure in AKS?

Select 3 answers
A.The node has too much memory.
B.Network connectivity issues to ACR.
C.Insufficient permissions (missing pull secrets).
D.The container is running too fast.
E.Invalid image tag or registry path.
AnswersB, C, E

Network connectivity issues to ACR directly satisfy the stem's requirement for a common pull failure cause. When the kubelet on a node cannot reach the registry endpoint, image layers never download, producing ImagePullBackOff. This occurs with misconfigured network policies, private endpoints, or DNS resolution failures blocking access to the container registry.

Why this answer

Option B is correct because AKS nodes must reach the registry endpoint (for example, myregistry.azurecr.io over HTTPS/443), and blocked egress, NSG/UDR misconfiguration, private endpoint or DNS resolution problems will cause the kubelet to fail the image pull. Option C is correct because pulling from a private registry such as ACR requires valid credentials — either an imagePullSecret, the AKS-managed AcrPull role assignment, or kubelet identity — and missing or expired permissions produce an authentication failure. Option E is correct because an invalid image tag or registry path (for example, a nonexistent tag or a misspelled registry/repository) makes the image unresolvable, yielding a manifest unknown or not found error.

Option A is not a pull failure cause: excessive node memory does not prevent image retrieval, and insufficient memory would instead cause scheduling or OOM issues. Option D is not relevant: how fast a container runs has no bearing on whether its image can be pulled from a registry.

Exam trap

AI-200 often tests distractors that sound plausible but are unrelated to image pulls (memory, runtime speed) — candidates must recognize that pull failures are strictly about network, auth, or image reference correctness.

161
MCQhard

You are containerizing a large language model (LLM) inference API to run in Azure Container Apps. The model weights exceed 15 GB and cause container startup timeouts because the image takes too long to pull from Azure Container Registry (ACR). You need to optimize the container startup performance without reducing the model size. What is the best approach?

A.Upgrade the Azure Container Apps environment to use HTTP/2 protocol.
B.Store the model weights in an Azure Blob Storage account and mount them via an ephemeral volume.
C.Configure ACR content trust and geo-replication.
D.Enable ACR artifact streaming for the container registry.
AnswerD

ACR artifact streaming lets Azure Container Apps pull individual image layers on demand rather than downloading the full 15 GB image first, cutting startup latency. The model size stays unchanged, satisfying the constraint that weights must not be reduced.

Why this answer

ACR artifact streaming lets ACR stream image layers directly to the container runtime on demand rather than requiring the full image to be pulled and extracted before startup. This dramatically reduces cold-start time for large images like LLM weight layers, without shrinking the model. It is the purpose-built ACR feature for exactly this startup-latency problem.

Exam trap

AI-200 often tests the confusion between image optimization techniques — candidates pick geo-replication or content trust thinking they speed up pulls, when only artifact streaming addresses large-layer startup latency.

How to eliminate wrong answers

Option A is wrong because HTTP/2 affects transport efficiency for API calls but does not change how image layers are pulled from ACR — it does not address the 15 GB pull bottleneck. Option B is wrong because mounting model weights from Blob Storage via an ephemeral volume still requires downloading the weights at container start, and it adds complexity (mount latency, SDK changes) without solving the fundamental pull-time problem; it also does not reduce the image pull itself. Option C is wrong because content trust (image signing) and geo-replication improve integrity and regional availability, not startup performance — geo-replication can reduce pull latency if the replica is closer, but it does not address the core large-layer streaming problem the way artifact streaming does.

162
Multi-Selecthard

You are designing a secure enterprise generative AI platform using Azure AI Search and Azure OpenAI. Which THREE security practices should you implement to protect sensitive data and access? (Choose three)

Select 3 answers
A.Implement Azure RBAC to restrict index management and data query permissions
B.Use Microsoft Entra ID managed identities for secure authentication between services
C.Disable transport layer security (TLS) to speed up embedding transmission
D.Store all API keys in plain text configuration files on public web servers
E.Configure Azure Private Endpoints for the Azure AI Search and Azure OpenAI services
AnswersA, B, E

Azure RBAC provides fine-grained role assignments separating index management from data query permissions, enforcing least privilege. This directly satisfies the stem's requirement to restrict who can administer indexes versus query data, protecting sensitive content in the generative AI platform.

Why this answer

Option A is correct because Azure RBAC provides fine-grained authorization over Azure AI Search, allowing you to separate roles such as Search Service Contributor (index management) from Search Index Data Reader/Contributor (query and data access), enforcing least privilege on sensitive indexes. Option B is correct because Microsoft Entra ID managed identities let Azure services authenticate to Azure OpenAI and Azure AI Search without embedding credentials, eliminating secret sprawl and enabling token-based access that can be scoped and audited. Option E is correct because Azure Private Endpoints assign private IP addresses from your VNet to Azure AI Search and Azure OpenAI, keeping traffic on the Microsoft backbone and blocking public internet exposure of these services.

Option C is wrong because disabling TLS would expose embedding payloads and queries to interception; TLS 1.2+ must remain enforced. Option D is wrong because storing API keys in plain text on public web servers directly exposes credentials, violating secret-management best practices such as Azure Key Vault or managed identities.

Exam trap

AI-200 often tests whether candidates recognize obvious security anti-patterns (plain text keys, disabled TLS) as distractors; the trap is picking a plausible-sounding but insecure option.

163
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

164
MCQeasy

Your development team wants to push custom Docker images containing fine-tuned open-source LLMs to a secure, private registry hosted on Azure. Which Azure service should you use to store and manage these container images?

A.Azure Files
B.Azure Artifacts
C.Azure Blob Storage
D.Azure Container Registry
AnswerD

Azure Container Registry is a private, managed Docker registry supporting authentication, RBAC and geo-replication, satisfying the secure private storage requirement for custom fine-tuned LLM images. It stores and manages OCI artefacts natively, unlike general blob storage or public registries.

Why this answer

Azure Container Registry (ACR) is Azure's managed, private Docker registry service, purpose-built to store, version, and distribute OCI-compliant container images and Helm charts. It supports geo-replication, private endpoints, content trust, and integration with AKS, Container Apps, and ACI, making it the correct choice for hosting fine-tuned LLM container images securely. Blob Storage and Azure Files can hold bytes but lack the Docker Registry HTTP API v2 needed for image push/pull.

Exam trap

AI-200 often tests whether candidates confuse generic storage (Blob, Files) with a true container registry, so the trap is picking Blob Storage because ACR 'uses blobs underneath' — but only ACR exposes the registry API.

How to eliminate wrong answers

Option A is wrong because Azure Files is an SMB/NFS file share service for general-purpose file data, not a container registry — it cannot serve Docker Registry API v2 requests. Option B is wrong because Azure Artifacts is a package feed for NuGet, npm, Maven, Python, and similar package types, not for OCI container images. Option C is wrong because Azure Blob Storage is object storage; while ACR internally uses blob storage as its backing store, you cannot push or pull Docker images directly against a blob container without the registry layer.

165
MCQeasy

You need to deploy a microservice application that consists of an API gateway and an AI model inference container. The solution must scale automatically based on HTTP traffic and support zero scaling when idle to reduce costs, without requiring complex Kubernetes cluster management. Which service is best suited for this?

A.Azure App Service for Containers
B.Azure Batch
C.Azure Container Apps
D.Azure Kubernetes Service (AKS)
AnswerC

Azure Container Apps provides HTTP-based KEDA scaling, including scale-to-zero when idle, and runs containers without exposing Kubernetes control-plane management. This satisfies both the automatic HTTP traffic scaling and zero-scaling cost requirements, whereas AKS demands cluster administration and Container Instances lack built-in autoscaling.

Why this answer

Azure Container Apps is a serverless container platform built on Kubernetes and KEDA that supports HTTP-based autoscaling, including scale-to-zero when idle. It abstracts away cluster management, making it ideal for microservices with an API gateway and an AI inference container that must scale on demand without operational overhead.

Exam trap

AI-200 often tests the distinction between scale-to-zero serverless containers (Container Apps) and always-on platforms (App Service) or self-managed orchestrators (AKS), with candidates overestimating App Service scaling capabilities.

How to eliminate wrong answers

Option A is wrong because Azure App Service for Containers does not support true scale-to-zero; it requires at least one running instance and has different scaling characteristics. Option B is wrong because Azure Batch is designed for large-scale parallel batch computing jobs, not for HTTP-triggered microservices with zero scaling. Option D is wrong because AKS requires managing Kubernetes clusters, nodes, and upgrades, which violates the 'without complex Kubernetes cluster management' requirement.

166
MCQeasy

You have deployed an AI model in Azure Machine Learning. You want to set up an alert that triggers an email to the operations team whenever the CPU utilization of the compute instance exceeds 90% for longer than 15 minutes. Which Azure Monitor feature should you configure?

A.Azure Cost Management anomaly alerts
B.Azure Monitor metric alerts with an action group
C.Azure Policy remediation tasks
D.Azure Service Health planned maintenance alerts
AnswerB

Metric alerts evaluate platform metrics such as CPU utilisation against a threshold, and the 15-minute sustained condition is handled by the alert rule's aggregation granularity and evaluation frequency. Attaching an action group delivers the email to the operations team, satisfying both the threshold and notification requirements.

Why this answer

Azure Monitor metric alerts are designed to evaluate numeric time-series data such as CPU utilization from Azure Machine Learning compute instances. By creating a metric alert with a threshold of 90% and a 15-minute aggregation window, you can detect sustained high CPU usage. An action group attached to the alert defines the notification channel, such as email to the operations team.

This is the standard, native way to implement resource-level performance alerting in Azure.

Exam trap

AI-200 often tests the distinction between monitoring and alerting features versus governance or cost tools; candidates may incorrectly choose Azure Policy or Cost Management because they confuse alerting with enforcement or budgeting.

How to eliminate wrong answers

Option A is wrong because Azure Cost Management anomaly alerts focus on detecting unexpected spending patterns and budgets, not real-time resource performance metrics like CPU utilization. Option C is wrong because Azure Policy remediation tasks are used to enforce compliance and automatically correct non-compliant resources (e.g., tagging, allowed locations), not to monitor and alert on performance thresholds. Option D is wrong because Azure Service Health planned maintenance alerts notify about platform-initiated maintenance events affecting Azure services, not about resource-level metrics such as CPU usage on a compute instance.

167
Multi-Selecthard

Which THREE of the following items should be configured to ensure your AI workload in AKS is observable?

Select 3 answers
A.Prometheus and Grafana.
B.Integration with Application Insights.
C.Azure Backup.
D.Azure Monitor for Containers.
E.Azure Bastion.
AnswersA, B, D

Prometheus scrapes and stores time-series metrics from AKS nodes and pods, while Grafana renders those metrics as dashboards and alerts. Together they satisfy the observability requirement by exposing workload telemetry that Azure Monitor alone may not surface at the granularity AI training jobs demand.

Why this answer

Prometheus and Grafana (A) are correct because they provide the standard open-source metrics collection and dashboarding stack for Kubernetes, scraping AKS node, pod, and container metrics via exporters and kube-state-metrics to visualize workload health and performance. Integration with Application Insights (B) is correct because it enables distributed tracing, request/dependency telemetry, and live metrics for the AI application code running in AKS, which is essential for observing model inference latency and failures. Azure Monitor for Containers (D) is correct because it is the native AKS monitoring solution that collects container logs, node and pod metrics, and events into Log Analytics, providing out-of-the-box insights and alerts for the cluster.

Azure Backup (C) is incorrect because it is a data protection and disaster recovery service, not an observability tool, and Azure Bastion (E) is incorrect because it provides secure RDP/SSH access to VMs without exposing public IPs, which is unrelated to monitoring or telemetry.

Exam trap

AI-200 often tests whether candidates can distinguish observability tooling (metrics, logs, traces) from operational tooling (backup, bastion), and multi-select questions punish including unrelated services.

168
MCQhard

You are configuring authentication between an Azure Container App running an AI model and an Azure OpenAI resource. To adhere to security best practices, you must avoid storing API keys in environment variables or code. How should you configure this?

A.Hardcode the secondary endpoint key into the Docker image build arguments
B.Enable anonymous public access on the Azure OpenAI resource for internal virtual network traffic
C.Configure a system-assigned managed identity on the Container App and grant it Cognitive Services OpenAI User role on the Azure OpenAI resource
D.Store the Azure OpenAI primary key in an Azure Key Vault and reference it via Container App secrets with plain text retrieval
AnswerC

A system-assigned managed identity lets the Container App obtain Microsoft Entra ID tokens for Azure OpenAI, with the Cognitive Services OpenAI User role granting access. No API keys are stored in code or environment variables, satisfying the security constraint.

Why this answer

A system-assigned managed identity on the Container App gives it an identity in Microsoft Entra ID, and granting that identity the Cognitive Services OpenAI User role on the Azure OpenAI resource authorizes token-based access without any stored secret. The Container App SDK/Managed Identity endpoint issues short-lived tokens automatically, eliminating keys in code or environment variables. This is the recommended keyless authentication pattern for Azure-to-Azure service calls.

Exam trap

The trap is treating Key Vault storage as equivalent to keyless auth; the exam wants managed identity plus RBAC, not secret retrieval, because the requirement is to avoid storing keys at all.

How to eliminate wrong answers

Option A is wrong because hardcoding a key into build arguments embeds the secret in image layers and build history, which is exactly the anti-pattern the question forbids. Option B is wrong because enabling anonymous public access removes authentication entirely and exposes the model to anyone who can reach the endpoint, violating least privilege. Option D is wrong because although Key Vault is better than hardcoding, retrieving the key as plain text into Container App secrets still materializes a long-lived secret in the app environment rather than using identity-based auth.

169
MCQeasy

You want to set up an alert when the availability of your Azure AI custom model endpoint drops below 99%. Which Azure service should you use?

A.Azure Policy definitions with audit effects.
B.Azure Cost Management anomaly detection.
C.Azure Monitor metric alerts configured on the 'Availability' or 'HttpServerErrors' metrics.
D.Microsoft Defender for Cloud vulnerability assessment.
AnswerC

Azure Monitor metric alerts evaluate platform metrics such as Availability and HttpServerErrors against a threshold, triggering when the endpoint drops below 99%. This satisfies the stem's requirement for availability alerting on the custom model endpoint without custom logging queries.

Why this answer

Azure Monitor metric alerts evaluate platform metrics such as Availability and HttpServerErrors against thresholds and fire notifications or actions when breached. Configuring a metric alert on Availability with a threshold below 99% is the direct way to detect endpoint availability drops.

Exam trap

AI-200 often tests whether candidates reach for governance (Policy) or security (Defender) tools when the question is purely about runtime monitoring — the keyword 'availability' points to Azure Monitor metrics.

How to eliminate wrong answers

Option A is wrong because Azure Policy is a governance tool that audits or enforces resource configurations — it does not monitor runtime availability of endpoints. Option B is wrong because Cost Management anomaly detection tracks spending patterns, not service availability. Option D is wrong because Defender for Cloud vulnerability assessment scans for security weaknesses (CVEs, misconfigurations), not live availability metrics.

170
MCQeasy

You need to deploy a quick, stateless AI data processing script packaged in a container image without setting up Kubernetes or Container Apps. Which Azure service offers the fastest deployment for a single container instance?

A.Azure Virtual Machines with Docker installed
B.Azure Container Instances
C.Azure App Service for Linux
D.Azure Kubernetes Service
AnswerB

Azure Container Instances runs a single container image directly with no cluster orchestration or environment scaffolding, billing per second of execution. This satisfies the stateless, fastest-deployment constraint by avoiding Kubernetes and Container Apps provisioning overhead entirely.

Why this answer

Azure Container Instances (ACI) is a serverless container runtime that deploys a single container (or container group) in seconds via a single CLI command or ARM template, with no cluster or orchestrator to provision. It bills per-second for vCPU and memory consumed, making it ideal for short-lived, stateless AI data processing jobs. Because there is no node pool, ingress controller, or control plane to manage, ACI delivers the fastest path from image to running container.

Exam trap

AI-200 often tests the distinction between 'fastest/simplest single-container deployment' (ACI) and 'orchestrated, scalable container platform' (AKS or Container Apps), so candidates over-engineer by choosing AKS when the scenario explicitly says no Kubernetes.

How to eliminate wrong answers

Option A is wrong because Azure Virtual Machines require you to provision the VM, install and patch Docker, configure networking and OS updates, and manage the host lifecycle — far slower than a serverless container service. Option C is wrong because Azure App Service for Linux is a PaaS web-hosting platform optimized for long-running web apps and APIs, not for quick one-off stateless container jobs, and it requires an App Service Plan with ongoing cost. Option D is wrong because Azure Kubernetes Service provisions a full managed Kubernetes control plane plus node pools, which takes minutes and adds orchestration overhead that is unnecessary for a single container instance.

171
Multi-Selecteasy

Which TWO actions can you perform using Azure Container Registry Tasks (ACR Tasks)?

Select 2 answers
A.Manage Azure Virtual Machine backups
B.Automate image builds upon Git source code repository commits
C.Build container images in the cloud without needing a local Docker daemon
D.Configure Azure Front Door routing rules
E.Deploy AKS clusters automatically
AnswersB, C

ACR Tasks supports automated builds triggered by source code commits to a Git repository, using quick tasks or multi-step task definitions. This satisfies the stem's automation requirement by rebuilding container images whenever code changes, removing manual intervention and enabling continuous integration directly within Azure Container Registry.

Why this answer

Option B is correct because ACR Tasks supports multi-step and single-step tasks that can be triggered automatically by source code commits to a Git repository (via the source trigger feature), enabling continuous integration image builds. Option C is correct because ACR Tasks performs builds in the Azure cloud using the ACR build infrastructure, so no local Docker daemon or Docker CLI is required on the developer's machine. Option A is incorrect because Azure Virtual Machine backups are handled by Azure Backup and Recovery Services vaults, not ACR Tasks.

Option D is incorrect because Azure Front Door routing rules are configured through Azure Front Door, a content delivery and global load-balancing service, unrelated to container image builds. Option E is incorrect because AKS cluster deployment is performed via the Azure portal, CLI, ARM/Bicep templates, or Terraform, not through ACR Tasks, which only builds and manages container images.

Exam trap

AI-200 often tests whether candidates confuse ACR Tasks (image build automation) with broader Azure services like AKS, Azure Backup, or Front Door, so any option mentioning cluster deployment or networking is a distractor.

172
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

173
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

174
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

175
MCQhard

An AKS cluster is configured with KEDA for autoscaling an AI inferencing service based on Azure Queue Storage length. The pods fail to scale. Which component should you inspect first?

A.The Azure Container Registry webhook settings.
B.The Horizontal Pod Autoscaler (HPA) resource directly.
C.The Cluster Autoscaler logs.
D.The ScaledObject resource status.
AnswerD

KEDA's ScaledObject holds the trigger configuration, polling interval and scaling status; a misconfigured or erroring ScaledObject prevents scaling entirely. Inspecting its status and events reveals authentication or queue-metric failures before checking the HPA or deployment.

Why this answer

KEDA works by creating and managing a Horizontal Pod Autoscaler behind the scenes, but the user-facing configuration object is the ScaledObject, which defines the trigger (Azure Queue Storage), min/max replicas, and target workload. If scaling fails, the ScaledObject's status conditions and events reveal authentication errors, trigger misconfiguration, or missing metadata. Inspecting it first is the fastest path to the root cause.

Exam trap

AI-200 often tests whether candidates know that KEDA creates the HPA automatically, so troubleshooting should start at the ScaledObject (the source of truth) rather than the HPA (the derived resource).

How to eliminate wrong answers

Option A is wrong because Azure Container Registry webhooks notify on image push/pull events and have no role in KEDA autoscaling decisions. Option B is wrong because the HPA is a downstream artifact created by KEDA; inspecting it directly shows symptoms (e.g., unknown metric) but not the trigger-level cause, and KEDA may not have created it if the ScaledObject is invalid. Option C is wrong because the Cluster Autoscaler adds or removes nodes when pods are unschedulable — it is a node-level concern, not the pod-replica scaling driven by KEDA.

176
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

177
MCQhard

You are deploying a custom AI model container to Azure Container Apps. The container listens on port 8080 and requires health probes to verify readiness before routing traffic. How should you configure the probes?

A.Configure an Azure Front Door health probe pointing to the internal container IP
B.Configure a TCP liveness probe pointing to port 22 for SSH management
C.Configure an HTTP readiness probe targeting port 8080 on your health check endpoint
D.Configure a startup probe that restarts the container if CPU usage drops below 5 percent
AnswerC

An HTTP readiness probe on port 8080 matches the container's listening port and verifies application-level readiness before Azure Container Apps routes traffic. HTTP probes validate a specific health endpoint returning success, unlike TCP probes which only confirm the port is open, so they satisfy the stem's requirement to verify readiness accurately.

Why this answer

Azure Container Apps supports HTTP and TCP probes defined at the container level, and an HTTP readiness probe is the correct mechanism to signal that the app is ready to receive traffic on its listening port. Since the container listens on port 8080 and exposes a health check endpoint, an HTTP readiness probe targeting that port lets the platform delay traffic routing until the endpoint returns a success status code. This matches the Kubernetes-style probe model that Container Apps implements, where readiness probes control traffic admission rather than process restart.

Exam trap

AI-200 often tests whether candidates confuse the three probe types — picking a liveness probe when readiness is required, or assuming probes can be defined at the ingress/Front Door layer instead of on the container itself.

How to eliminate wrong answers

Option A is wrong because Azure Front Door health probes operate at the edge/ingress layer against a public or private endpoint, not against an internal container IP inside the Container Apps environment, and Front Door is not the component that gates revision traffic routing. Option B is wrong because port 22 is SSH, not the application's listening port, and a TCP liveness probe against SSH would only verify that the SSH daemon is accepting connections — it says nothing about whether the AI model HTTP service on 8080 is ready. Option D is wrong because startup probes in Container Apps are HTTP or TCP checks against the container, not CPU-threshold monitors, and restarting on low CPU is a nonsensical readiness signal that would cause flapping.

178
MCQhard

You are troubleshooting a live AI web application where users report intermittent 504 Gateway Timeout errors when submitting large text prompts to a custom model endpoint. You want to check if the backend inference container is timing out or crashing. Where should you examine container-level stdout/stderr logs in Azure Container Apps?

A.Log Analytics workspace querying the ContainerAppConsoleLogs_CL table
B.Azure Cosmos DB request unit (RU) consumption logs
C.Azure Key Vault audit logs
D.Azure Advisor performance recommendations
AnswerA

Querying ContainerAppConsoleLogs_CL in Log Analytics retrieves the container's stdout/stderr streams, exactly the diagnostic data needed to distinguish an inference timeout from a crash. Azure Container Apps forwards console output to this table, satisfying the stem's requirement to inspect container-level logs rather than platform or HTTP metrics.

Why this answer

Azure Container Apps writes container stdout/stderr to the Log Analytics workspace associated with the Container Apps environment, where it is queryable in the ContainerAppConsoleLogs_CL table. This is the canonical location for container-level logs, including crash traces, stack dumps, and application output that would reveal inference timeouts or OOM kills. Querying this table lets you correlate timestamps with the 504 errors reported by users.

Exam trap

The trap here is confusing observability data sources: candidates may pick Cosmos DB RU logs or Key Vault audit logs because they sound like 'diagnostic' sources, but only ContainerAppConsoleLogs_CL holds container stdout/stderr.

How to eliminate wrong answers

Option B is wrong because Cosmos DB RU consumption logs track database throughput and throttling (429s), not container stdout/stderr from an inference workload. Option C is wrong because Key Vault audit logs record secret/key access operations, not application runtime output. Option D is wrong because Azure Advisor provides best-practice recommendations and does not contain live container logs.

179
MCQeasy

You want to view real-time standard output logs from a container running in Azure Container Instances named 'ai-inferencing-aci'. Which Azure CLI command should you run?

A.az container show --resource-group myRG --name ai-inferencing-aci
B.az aks browse --name ai-inferencing-aci
C.az container logs --resource-group myRG --name ai-inferencing-aci
D.az acr repository show-tags
AnswerC

The az container logs command streams a container group's stdout, and --name identifies the container group while --resource-group scopes it. This returns the real-time standard output for ai-inferencing-aci, which az container show or attach would not provide.

Why this answer

The 'az container logs' command retrieves the stdout/stderr logs from a container running in Azure Container Instances, which is exactly what is needed to view real-time standard output. It accepts --resource-group and --name to identify the container group and supports --follow to stream logs continuously. This is the canonical CLI command for ACI log inspection.

Exam trap

AI-200 often tests whether candidates confuse 'az container show' (metadata/state) with 'az container logs' (runtime output), or mix up ACI commands with AKS commands like 'az aks browse'.

How to eliminate wrong answers

Option A is wrong because 'az container show' returns the container group's metadata and provisioning state (JSON properties), not its runtime logs. Option B is wrong because 'az aks browse' opens the Kubernetes dashboard for an AKS cluster and is unrelated to ACI; the resource is a container instance, not an AKS cluster. Option D is wrong because 'az acr repository show-tags' lists tags in an Azure Container Registry repository — it inspects image metadata, not running container output.

180
MCQmedium

You are designing the data architecture for an AI-powered document search application. You choose Azure AI Search because you need multi-lingual support, faceted navigation, and vector search. What is the maximum number of vector fields allowed per index in Azure AI Search?

A.Exactly one vector field per index
B.A maximum of two vector fields
C.Multiple vector fields are supported per index
D.Vector fields are not supported in Azure AI Search
AnswerC

Azure AI Search indexes permit many vector fields, each with its own dimensions, algorithm and profile, so a single index can hold multiple embeddings. This supports the multi-lingual, faceted and vector search requirements without splitting data across indexes.

Why this answer

Azure AI Search supports multiple vector fields per index, allowing you to store and query different embeddings (e.g., text, image, or multi-model vectors) within the same index. Each vector field is defined with its own dimensions and similarity metric, and you can target specific fields in vector queries. This flexibility is essential for hybrid and multi-modal search scenarios.

Exam trap

AI-200 often tests assumed limitations, tricking candidates who believe vector search is restricted to one field per index when Azure AI Search actually supports many.

How to eliminate wrong answers

Option A is wrong because Azure AI Search does not restrict indexes to a single vector field — that limitation does not exist in the service. Option B is wrong because there is no hard cap of two vector fields; the actual limit is much higher (up to 1024 fields per index, with vector fields counting toward that). Option D is wrong because vector search is a core, generally available feature of Azure AI Search, not an unsupported capability.

181
Multi-Selecthard

You are auditing an Azure AI platform for security vulnerabilities. You want to ensure that secrets, connection strings, and certificates are handled in compliance with security best practices. Which THREE of the following practices should you enforce? (Choose three)

Select 3 answers
A.Implement automated secret rotation policies for API keys and service credentials.
B.Commit production database passwords to public GitHub repositories for easy developer access.
C.Grant every employee administrator access to all Key Vault secrets.
D.Use managed identities instead of embedding static connection strings in application configuration files.
E.Enable Key Vault soft-delete and purge protection to prevent accidental permanent deletion of secrets.
AnswersA, D, E

Automated rotation limits the window in which a leaked API key or credential remains usable, satisfying the audit's requirement for compliant secret handling. Stale secrets are replaced on schedule without manual intervention, reducing exposure from long-lived credentials.

Why this answer

Option A is correct because automated secret rotation policies for API keys and service credentials limit the blast radius of a leaked secret by ensuring credentials expire and are replaced on a schedule, which is a core Azure Key Vault and security best-practice control. Option D is correct because managed identities let Azure services authenticate to resources such as Key Vault and Azure SQL without storing static connection strings or credentials in application configuration files, eliminating a common credential-exposure vector. Option E is correct because enabling Key Vault soft-delete and purge protection prevents accidental or malicious permanent deletion of secrets, certificates, and keys, preserving recoverability during the retention period.

Option B is wrong because committing production database passwords to public GitHub repositories exposes credentials to anyone and violates every secret-management best practice. Option C is wrong because granting every employee administrator access to all Key Vault secrets violates least privilege and dramatically increases the risk of insider misuse or compromise.

182
MCQhard

You deploy an AI inferencing service to an Azure Kubernetes Service (AKS) cluster. The service uses an ONNX Runtime container. Users report intermittent 504 Gateway Timeouts during peak batch request loads. You notice that the application pods are being terminated due to Out-Of-Memory (OOM) errors during heavy inference loads. How should you resolve this issue in your Kubernetes deployment manifest?

A.Decrease the readiness probe failureThreshold to remove faulty pods faster.
B.Increase the memory limit value in the container resource specifications.
C.Enable the Kubernetes Horizontal Pod Autoscaler based on CPU utilization.
D.Configure a liveness probe with an increased initialDelaySeconds value.
AnswerB

OOM kills stem from the container exceeding its memory limit during heavy inference, so raising the memory limit value in the resource specifications gives pods headroom to complete batch requests without termination, addressing the root cause rather than the resulting 504 timeouts.

Why this answer

The pods are being OOM-killed because the container's memory limit is lower than the peak memory required during heavy inference. Increasing the memory limit in the container resource specifications gives the ONNX Runtime process enough headroom to complete batch inference without being terminated by the kernel OOM killer. This directly addresses the root cause of the 504 timeouts, which occur because pods die mid-request.

Exam trap

AI-200 often tests the distinction between scaling out (HPA) and scaling up (resource limits), tricking candidates into choosing HPA when the actual symptom is per-pod OOM termination.

How to eliminate wrong answers

Option A is wrong because decreasing the readiness probe failureThreshold only affects how quickly a pod is marked unready; it does not prevent OOM kills and could even remove pods faster without fixing the underlying memory shortage. Option C is wrong because HPA based on CPU scales out replicas but does not increase per-pod memory; if each pod still OOMs under load, adding more pods may not help and could worsen node-level memory pressure. Option D is wrong because increasing initialDelaySeconds on a liveness probe only delays the first probe; it does not address OOM termination, which is enforced by the kernel, not the probe.

183
MCQeasy

You need to view the logs of a container that recently crashed in an AKS cluster. Which command is used?

A.kubectl get pods.
B.az aks logs.
C.kubectl describe pod.
D.kubectl logs <pod-name> --previous.
AnswerD

The --previous flag retrieves logs from the terminated instance of the container, which is essential after a crash because the current pod may have restarted. Plain kubectl logs shows only the running container, so --previous satisfies the need to inspect the crashed instance's output.

Why this answer

The `kubectl logs <pod-name> --previous` command retrieves the logs from the previous (crashed) container instance in a pod. When a container crashes and restarts, the current container's logs may be empty or show only the new startup, so the `--previous` flag is essential to access the terminated container's output. This is the standard kubectl mechanism for post-mortem debugging of crashed containers in AKS.

Exam trap

AI-200 often tests the distinction between `kubectl describe pod` (events and state) and `kubectl logs --previous` (actual crash output), tricking candidates who assume describe shows logs.

How to eliminate wrong answers

Option A is wrong because `kubectl get pods` only lists pods and their status/restart counts — it does not retrieve any log output. Option B is wrong because `az aks logs` is not a valid Azure CLI command; AKS log retrieval is done via kubectl or Azure Monitor/Container Insights, not a direct `az aks logs` subcommand. Option C is wrong because `kubectl describe pod` shows events, status conditions, and container state (including last termination reason) but not the actual stdout/stderr log content of the crashed container.

184
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

185
MCQmedium

You are configuring an Azure OpenAI service instance. You need to ensure that the service is only accessible from your corporate virtual network and that public internet access is completely disabled. Which configuration should you implement?

A.Set the firewall rules to block all traffic and allow only the specific IP address of your NAT gateway.
B.Configure a Service Tag in the Network Security Group to allow only specific IP ranges.
C.Implement Azure AD Conditional Access policies to restrict access based on user location.
D.Create a Private Endpoint, disable public network access in the Networking tab, and verify the DNS zone configuration.
AnswerD

A Private Endpoint assigns a private IP from your virtual network, and disabling public network access blocks all internet traffic. The DNS zone must resolve the service name to that private IP, otherwise clients still hit the public endpoint, so verification is essential.

Why this answer

To make an Azure OpenAI instance reachable only from a corporate VNet with no public internet access, you must create a Private Endpoint (which assigns a private IP from your VNet to the service), disable public network access on the Networking tab, and ensure the private DNS zone (privatelink.openai.azure.com) is linked so name resolution returns the private IP. All three steps are required for a fully private, functional deployment.

Exam trap

The trap is believing that IP allow-listing or Conditional Access achieves 'no public access'; the exam expects recognition that only a Private Endpoint plus disabled public access (with correct DNS) delivers true private-only connectivity.

How to eliminate wrong answers

Option A is wrong because allowing only a NAT gateway IP still leaves the service publicly reachable from that IP and does not provide VNet-internal private connectivity; it also does not disable public access. Option B is wrong because Service Tags in NSGs control traffic to Azure service IP ranges from your subnets, but they do not make the Azure OpenAI resource private or disable its public endpoint. Option C is wrong because Conditional Access is an identity control based on user/location/device signals and does not remove the public network endpoint or provide private IP connectivity.

186
MCQhard

You are monitoring an Azure Machine Learning online endpoint that serves a real-time inference model. You need to detect when the model's input data distribution drifts from the training data and trigger an alert. Which Azure Machine Learning feature should you use?

A.Azure Machine Learning responsible AI dashboard with error analysis.
B.Azure Monitor Application Insights with custom telemetry for input data.
C.Azure Machine Learning data drift detection with a monitor on the deployed model.
D.Azure Machine Learning model performance monitoring using the model's accuracy metric.
AnswerC

Azure Machine Learning provides data drift detection for deployed models. You can configure a monitor that compares incoming inference data against a baseline dataset and computes drift metrics. When drift exceeds a threshold, it can trigger alerts. This is the correct feature to detect input data distribution changes.

Why this answer

Azure Machine Learning data drift detection allows you to monitor a deployed model's input data against a baseline and set up alerts when drift exceeds a threshold. This is the built-in feature for detecting changes in data distribution, making it the correct choice for the scenario.

Exam trap

The trap here is confusing data drift detection with model performance monitoring; the former focuses on input distribution, while the latter requires ground truth labels.

187
MCQhard

You are configuring role-based access control for an Azure AI Search service. A data scientist needs to index content and query documents, but must not be permitted to manage service-level keys or change admin configurations. Which built-in role should you assign?

A.Search Service Contributor
B.Search Index Data Contributor
C.Cognitive Services Contributor
D.Storage Blob Data Reader
AnswerB

Search Index Data Contributor grants read and write access to index content and queries, covering indexing and document querying. It excludes service-level key management and admin configuration changes, satisfying the least-privilege constraint that the data scientist must not manage keys or alter service settings.

Why this answer

Search Index Data Contributor grants data-plane rights to read and write documents in indexes and to query them, which is exactly what a data scientist needs. It does not include the control-plane permissions to manage service keys, scale the service, or change admin configuration. That separation of duties matches the stated requirement.

Exam trap

AI-200 often tests the confusion between control-plane roles (Search Service Contributor) and data-plane roles (Search Index Data Contributor) — candidates pick the role with 'Contributor' in the name without checking the plane.

How to eliminate wrong answers

Option A is wrong because Search Service Contributor is a control-plane role that can manage the service, keys, and indexes but does not grant data-plane document read/write access. Option C is wrong because Cognitive Services Contributor is a broad control-plane role for Cognitive Services accounts and does not grant Azure AI Search index data access. Option D is wrong because Storage Blob Data Reader only reads blobs in Storage accounts and has no relationship to Azure AI Search indexes.

188
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

189
MCQhard

You are deploying a model that requires a specific version of a non-standard OS library. You want to ensure the build environment is consistent across your team. What should you use?

A.Manual installation on the build agent.
B.A Dockerfile with fixed base image tags.
C.Install the library via a post-deployment script.
D.Use the 'latest' tag for the base image.
AnswerB

A Dockerfile with pinned base image tags locks the OS layer and library versions, so every teammate builds against the identical environment. This directly satisfies the stem's requirement for a consistent build environment when a specific non-standard OS library version is needed, rather than relying on mutable tags or host configuration.

Why this answer

A Dockerfile with pinned base image tags (e.g., python:3.11.7-slim rather than python:latest) guarantees that every team member and CI run builds against the exact same OS libraries and toolchain. This reproducibility is the core requirement for consistent build environments.

Exam trap

AI-200 often tests the misconception that 'latest' is a stable, reproducible tag — candidates pick it thinking it always gives the newest, most consistent environment, when it actually introduces drift.

How to eliminate wrong answers

Option A is wrong because manual installation on the build agent is not reproducible — different agents drift, and the environment cannot be version-controlled or shared. Option C is wrong because a post-deployment script runs after the artifact is built, so it cannot guarantee the build environment itself is consistent and may fail at runtime. Option D is wrong because the 'latest' tag is mutable and can silently pull a newer base image, breaking reproducibility and introducing unexpected library changes.

190
MCQhard

You are designing a multi-tenant enterprise RAG system using Azure AI Search. Each tenant requires isolated document retrieval. Which feature should you implement to enforce data security while leveraging vector search?

A.Role-Based Access Control (RBAC) at the index level
B.Dedicated search services per tenant without filters
C.Security trimming using OData filter expressions with vector queries
D.Semantic ranker query throttling
AnswerC

Security trimming applies OData filter expressions on a tenant identifier field alongside the vector query, restricting each tenant's results to its own documents. This enforces retrieval isolation while still leveraging vector search across the shared index.

Why this answer

Security trimming with OData filter expressions applied alongside vector queries enforces per-tenant isolation at query time, ensuring each tenant only retrieves documents matching their tenant ID or security group. Azure AI Search supports combining vector search with OData $filter so the vector similarity search is constrained to the authorized document subset.

Exam trap

AI-200 often tests the misconception that index-level RBAC provides document-level isolation, when true multi-tenant security requires filterable security-trimming fields in the query.

How to eliminate wrong answers

Option A is wrong because RBAC at the index level controls who can query the index, not which documents within a shared index a tenant can see — it cannot enforce row-level document isolation. Option B is wrong because dedicated search services per tenant is prohibitively expensive and operationally unscalable for multi-tenant SaaS, and 'without filters' provides no logical isolation if data is ever co-located. Option D is wrong because semantic ranker throttling is a performance/rate-limit control, not a security mechanism, and has no bearing on tenant data isolation.

191
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

192
MCQeasy

You are deploying a web application container to Azure Container Apps and want to enable external HTTPS traffic. Which ingress setting must you configure?

A.Set target port to 80 and protocol to TCP
B.Enable ingress with external traffic permitted
C.Disable ingress entirely
D.Configure internal ingress only
AnswerB

Ingress must be enabled with external traffic permitted so the container app receives a publicly resolvable FQDN and terminates HTTPS at the platform's ingress controller. Internal-only ingress would restrict access to the Container Apps environment, failing the stem's external HTTPS requirement.

Why this answer

To expose a Container App to the public internet over HTTPS, you must enable ingress and set it to accept external traffic. Container Apps then provisions a fully qualified domain name (FQDN) and a managed TLS certificate automatically, terminating HTTPS at the ingress layer. Without external ingress enabled, the app is only reachable inside the environment.

Exam trap

The trap is thinking that setting a port or protocol is sufficient for external HTTPS; candidates must remember that ingress must be explicitly enabled and set to external to get a public FQDN and managed TLS.

How to eliminate wrong answers

Option A is wrong because setting target port 80 and protocol TCP alone does not enable ingress or external exposure — ingress must be enabled and set to external. Option C is wrong because disabling ingress makes the app unreachable from any network, including the internet. Option D is wrong because internal ingress only exposes the app within the Container Apps environment or VNet, not to the public internet.

193
MCQmedium

You are designing an application that requires low-latency vector search for a high-traffic AI chatbot. You need to ensure the vector index remains performant as the dataset grows into millions of documents. Which index configuration in Azure AI Search should you implement to optimize for speed over absolute recall accuracy?

A.Flat Indexing
B.Exhaustive KNN
C.HNSW
D.Partitioned Indexing
AnswerC

HNSW is an approximate nearest neighbour graph index that trades a small amount of recall accuracy for substantially lower query latency and better scalability, keeping vector search performant as the dataset grows to millions of documents.

Why this answer

HNSW (Hierarchical Navigable Small World) is a graph-based approximate nearest neighbor (ANN) algorithm that builds a multi-layer navigable graph, delivering sub-linear query latency with high recall. In Azure AI Search, HNSW is the recommended index configuration for high-traffic, low-latency vector search over millions of documents when you can trade a small amount of recall for speed.

Exam trap

AI-200 often tests the confusion between exact KNN (Flat/Exhaustive) and approximate ANN (HNSW), causing candidates to pick Flat for accuracy when the question explicitly prioritizes speed over recall.

How to eliminate wrong answers

Option A is wrong because Flat indexing (exhaustive KNN) performs a brute-force scan of every vector, which is accurate but scales linearly — unacceptable for millions of documents and high traffic. Option B is wrong because Exhaustive KNN is the same brute-force approach as Flat; it guarantees exact recall but at prohibitive latency and cost at scale. Option D is wrong because Partitioned Indexing is a horizontal scaling technique for distributing data across shards, not an ANN algorithm — it does not by itself optimize for speed over recall.

194
Multi-Selectmedium

Your team is choosing between using Azure AI Search or Cosmos DB for NoSQL for a new project. Which TWO factors are key considerations that favor Azure AI Search?

Select 2 answers
A.Need for deep integration with full-text search (BM25) and hybrid search.
B.Requirement to store petabytes of data.
C.Requirement for high-frequency transactional ACID updates to metadata.
D.Need for built-in semantic re-ranking for better accuracy.
E.Need for lowest possible latency at the database level.
AnswersA, D

Azure AI Search natively ranks results using BM25 relevance scoring and supports hybrid queries that fuse keyword and vector results, satisfying the stem's full-text and hybrid search requirement. Cosmos DB for NoSQL offers no built-in BM25 ranking or hybrid retrieval, so it cannot meet this constraint without external indexing.

Why this answer

Option A is correct because Azure AI Search is purpose-built as a search engine that natively supports full-text search using the BM25 ranking algorithm as well as hybrid search that combines keyword and vector queries, which Cosmos DB for NoSQL does not provide out of the box. Option D is correct because Azure AI Search includes built-in semantic re-ranking (semantic ranker/L2 reranking) that reorders results using deep-learning models to improve relevance and accuracy, a capability Cosmos DB for NoSQL lacks natively. Option B is not a factor favoring Azure AI Search, since petabyte-scale storage is a strength of Cosmos DB for NoSQL rather than a search service.

Option C is not a factor favoring Azure AI Search, because high-frequency transactional ACID updates to metadata are handled by Cosmos DB for NoSQL's transactional capabilities, not by a search index. Option E is not a factor favoring Azure AI Search, as lowest possible database-level latency is a characteristic of Cosmos DB for NoSQL's globally distributed, low-latency data plane rather than the search service.

Exam trap

AI-200 often tests whether candidates conflate 'vector search' with 'search relevance' — Cosmos DB can do vector search, but only Azure AI Search provides BM25, hybrid fusion, and semantic reranking out of the box.

195
MCQmedium

You have an Azure OpenAI model deployment and need to monitor token consumption metrics over time to forecast future usage. Which tool provides pre-built charts for prompt and completion token counts?

A.Azure Monitor metrics explorer on the Azure OpenAI resource.
B.Microsoft Purview data lineage maps.
C.Azure Advisor cost optimization recommendations.
D.Azure Log Analytics workspace without Application Insights configured.
AnswerA

Azure Monitor metrics explorer surfaces the platform metrics emitted by an Azure OpenAI resource, including prompt and completion token counts, as pre-built charts. It satisfies the forecasting requirement by plotting token consumption over time without custom logging queries.

Why this answer

Azure Monitor metrics explorer surfaces the built-in Azure OpenAI metrics, including Prompt Tokens, Completion Tokens, and Total Tokens, as pre-built charts on the Azure OpenAI resource. These metrics are emitted automatically per deployment and can be split by model or deployment name, making them the fastest way to trend token consumption for capacity forecasting.

Exam trap

AI-200 often tests whether candidates know that Azure OpenAI token metrics are available out-of-the-box in Azure Monitor metrics explorer, versus assuming they must first configure Log Analytics or Application Insights to see any token data.

How to eliminate wrong answers

Option B is wrong because Microsoft Purview data lineage maps track data movement and governance across sources, not runtime token metrics. Option C is wrong because Azure Advisor provides cost and reliability recommendations, not time-series token charts. Option D is wrong because a Log Analytics workspace without Application Insights configured has no Azure OpenAI token telemetry piped in — diagnostic settings must be enabled and Application Insights or a workspace must receive the logs before any querying is possible.

196
MCQhard

You are setting up monitoring for a custom machine learning scoring script running inside an Azure Container Instance. You want to track custom metrics such as inference prediction confidence scores over time in Application Insights. How should you record these custom metrics in your Python scoring script?

A.Save the metrics as text files in an Azure Blob Storage account and run hourly KQL queries
B.Use the Application Insights TelemetryClient track_metric() method
C.Print JSON strings to standard output and rely on Log Analytics automatic table parsing
D.Update Azure Key Vault secrets with the metric values
AnswerB

TelemetryClient.track_metric() sends custom metric telemetry directly to Application Insights, letting the scoring script emit prediction confidence values that appear in the customMetrics table for time-series analysis. This satisfies the requirement to track custom metrics over time rather than relying on auto-collected request telemetry.

Why this answer

The Application Insights SDK for Python provides the TelemetryClient class with a track_metric() method specifically designed to record custom metrics. Calling track_metric() sends the value to Application Insights, where it becomes queryable in the customMetrics table and can be charted over time. This is the native, supported way to instrument custom metrics from any Python process, including one running in an Azure Container Instance.

Exam trap

AI-200 often tests the misconception that printing logs or writing files is equivalent to emitting custom metrics, when Application Insights requires the SDK's track_metric() for proper metric ingestion and querying.

How to eliminate wrong answers

Option A is wrong because writing metrics to Blob Storage and running hourly KQL queries is a batch workaround that introduces latency, requires custom parsing, and does not leverage Application Insights' real-time metric ingestion. Option C is wrong because printing JSON to stdout relies on Log Analytics automatic parsing, which is unreliable for structured metrics and does not populate the customMetrics table; it also lacks the SDK's buffering, sampling, and correlation features. Option D is wrong because Key Vault is a secrets management service, not a telemetry store, and updating secrets with metric values is a misuse of the service that provides no monitoring capability.

197
MCQmedium

Your application uses Cosmos DB for NoSQL to store product metadata and vectors. You need to perform a vector search that combines similarity scores with specific filter criteria on the 'category' field. How should you define your index policy to support this?

A.Define a vector index policy and include the 'category' property in the indexing policy's included paths.
B.Create a vector index policy containing only the vector embedding path.
C.Enable auto-indexing for all properties to ensure vector search works.
D.Use a stored procedure to perform the filter after the vector search result set is returned.
AnswerA

Cosmos DB for NoSQL evaluates vector similarity and filter predicates together only when the filtered property is indexed. Adding 'category' to the indexing policy's included paths lets the query engine apply the filter alongside the vector index, avoiding a full scan.

Why this answer

For vector search with pre-filtering in Cosmos DB for NoSQL, the index policy must include both a vector index policy for the embedding path and a regular indexing policy that includes the filter property (e.g., 'category'). This allows the query engine to apply the filter efficiently before or alongside the vector similarity search, reducing the candidate set and improving performance.

Exam trap

AI-200 often tests the misconception that a vector index alone suffices for filtered vector search — candidates must remember to include scalar filter properties in the indexing policy.

How to eliminate wrong answers

Option B is wrong because a vector index policy containing only the embedding path omits the 'category' property, so filter predicates on 'category' cannot be efficiently evaluated and may force a full scan or fail. Option C is wrong because enabling auto-indexing for all properties does not configure the vector index policy required for vector search; vector indexes must be explicitly defined with type, dimensions, and distance function. Option D is wrong because performing filtering after vector search in a stored procedure is inefficient and defeats the purpose of integrated filtering, potentially returning irrelevant results and increasing RU consumption.

198
MCQmedium

You want to ensure your AI inference service is highly available across multiple regions. What is the recommended approach for container distribution?

A.Store images in a public Docker Hub account.
B.Use a single global ACR endpoint.
C.Manually copy images using a script.
D.Enable ACR Georeplication.
AnswerD

ACR georeplication maintains registry replicas in each chosen Azure region, so container pulls resolve locally rather than crossing regions. This directly satisfies the multi-region availability constraint: if one region fails, inference nodes still pull images from their nearest healthy replica, avoiding a single-region registry as a failure point.

Why this answer

ACR geo-replication lets a single registry definition replicate images to multiple Azure regions automatically, so each regional inference endpoint pulls from a local replica with low latency and survives a regional outage. It also supports regional failover without manual image copying.

Exam trap

AI-200 often tests whether candidates confuse 'global endpoint' with geo-replication — ACR has no single global endpoint; geo-replication is the actual HA mechanism.

How to eliminate wrong answers

Option A is wrong because Docker Hub is a public third-party registry with rate limits, no SLA, and no private-network integration — unsuitable for production AI inference. Option B is wrong because ACR does not offer a single 'global endpoint' that magically serves all regions; without geo-replication, pulls cross regions and add latency. Option C is wrong because manual copy scripts are error-prone, slow, and create drift between regions — the opposite of a managed HA pattern.

199
MCQhard

You are designing a data architecture on Azure where embeddings are generated offline by an Azure Databricks pipeline and stored in Azure AI Search. You want to minimize ingestion latency and optimize throughput when uploading millions of pre-computed vectors. Which client library API pattern should you use?

A.Use SearchClient batch upload APIs with up to 1000 documents per batch
B.Stream vectors directly through the Azure AI Search integrated vectorizer skillset
C.Send documents one-by-one using synchronous CreateOrUpdate API calls
D.Execute direct SQL INSERT statements against the underlying search partition nodes
AnswerA

Batching up to 1000 documents per request via SearchClient's upload APIs maximises throughput for millions of pre-computed vectors, since each call amortises network and indexing overhead across many documents. Because embeddings are generated offline, no enrichment is needed, so this pattern directly minimises ingestion latency against the stated constraint.

Why this answer

The Azure AI Search SDK's SearchClient supports batch indexing via IndexDocumentsBatch or the mergeOrUpload/upload actions, and the service accepts up to 1000 documents (or ~16 MB) per batch request. Batching pre-computed vectors this way amortizes HTTP overhead and maximizes indexing throughput, which is exactly what you want when pushing millions of embeddings generated offline by Databricks. This is the documented, supported high-throughput ingestion pattern.

Exam trap

The trap is assuming the integrated vectorizer is the fastest path for pre-computed vectors; in reality it is a text-to-vector skill at index time, and the correct high-throughput pattern is batched SDK uploads capped at 1000 documents per request.

How to eliminate wrong answers

Option B is wrong because the integrated vectorizer skillset is for generating embeddings at index time from text using an Azure OpenAI or similar skill — it is not a transport for pre-computed vectors and adds latency rather than reducing it. Option C is wrong because one-by-one synchronous CreateOrUpdate calls incur per-request overhead and round-trip latency, making millions of vectors impractically slow. Option D is wrong because Azure AI Search is a managed service with no direct SQL access to underlying partition nodes; such statements are not a supported ingestion mechanism.

200
Multi-Selecteasy

Which TWO of the following are true about Azure Container Apps?

Select 2 answers
A.You must manage the underlying Kubernetes nodes.
B.It is a serverless container platform.
C.It is not compatible with Dapr.
D.It supports KEDA for event-driven scaling.
E.It does not support VNETs.
AnswersB, D

Azure Container Apps abstracts the underlying Kubernetes infrastructure, scaling to zero when there is no traffic and charging only for consumed resources. This serverless execution model satisfies the stem's requirement by removing cluster management overhead, letting teams deploy containerised workloads without provisioning or paying for idle nodes.

Why this answer

Azure Container Apps is a fully managed, serverless container platform, so option B is correct: it abstracts away the Kubernetes control plane and nodes, letting you run containers without provisioning or managing infrastructure. Option D is also correct because Azure Container Apps uses KEDA (Kubernetes Event-driven Autoscaling) under the hood to scale containers based on events such as queues, HTTP traffic, or custom metrics. Option A is wrong because node management is handled by the platform, not the user.

Option C is wrong because Azure Container Apps has built-in Dapr integration for microservice building blocks. Option E is wrong because Azure Container Apps supports virtual network (VNET) integration for inbound and outbound connectivity.

Exam trap

AI-200 often tests the boundary between AKS (you manage nodes) and Container Apps (serverless, no node access), and candidates incorrectly assume Container Apps lacks enterprise networking or Dapr support.

201
Multi-Selecteasy

When configuring an Azure Container Instances container group, which TWO properties can you define?

Select 2 answers
A.AKS node pool sizing
B.DNS name label for public IP resolution
C.Virtual machine scale set autoscaling rules
D.Kubernetes namespace allocation
E.Environment variables passed to the container runtime
AnswersB, E

Assigning a DNS name label gives the group's public IP a resolvable fully qualified domain name, enabling external clients to reach exposed ports. This is a definable container group property, satisfying the stem's requirement for configurable group settings.

Why this answer

Option B is correct because an Azure Container Instances container group can be exposed with a public IP address that includes a DNS name label, allowing resolution via <dns-name-label>.<region>.azurecontainer.io. Option E is correct because container groups support defining environment variables (including secure values) that are passed to the container runtime at startup, which is a core configuration property of ACI containers. Options A and C are incorrect because AKS node pool sizing and VM scale set autoscaling rules belong to AKS and Virtual Machine Scale Sets respectively, not to ACI container group configuration.

Option D is incorrect because Kubernetes namespace allocation is a Kubernetes/AKS concept and is not a property you define when configuring an ACI container group.

Exam trap

AI-200 often tests ACI vs AKS boundaries, so the trap is selecting Kubernetes/VMSS concepts (node pools, namespaces, autoscaling) that do not exist in ACI.

202
MCQhard

You are configuring GPU time-slicing on an AKS cluster to maximize GPU utilization for multiple lightweight AI inference containers sharing a single NVIDIA A100 GPU. Where must you define the time-slicing configuration profile?

A.Inside the Dockerfile of each individual AI container
B.A Kubernetes ConfigMap referenced by the NVIDIA device plugin daemonset
C.Via Azure Container Apps workload profiles configuration
D.In the Azure portal under AKS cluster node pool properties
AnswerB

Time-slicing profiles are declared in a ConfigMap that the NVIDIA device plugin DaemonSet consumes, letting one A100 advertise multiple shared replicas to the scheduler. This satisfies the stem's requirement to maximise utilisation across lightweight inference containers, since the profile must exist before the plugin starts and cannot be set per pod.

Why this answer

A Kubernetes ConfigMap referenced by the NVIDIA device plugin daemonset is correct because GPU time-slicing on AKS is configured by creating a ConfigMap that contains the time-slicing profile (e.g., replicas: 4) and referencing it in the NVIDIA device plugin daemonset spec via a volume mount. The device plugin then advertises multiple virtual GPU resources per physical GPU, allowing multiple pods to share the A100.

Exam trap

AI-200 often tests the misconception that GPU sharing is configured in the container image or Azure portal, when in AKS it is always a Kubernetes ConfigMap consumed by the NVIDIA device plugin daemonset.

How to eliminate wrong answers

Option A is wrong because the Dockerfile builds the container image and has no visibility into GPU scheduling or the device plugin — time-slicing is a cluster-level GPU resource configuration, not an image-level setting. Option C is wrong because Azure Container Apps workload profiles are a different compute platform (serverless containers) and do not manage AKS GPU device plugin configuration; time-slicing is an AKS/NVIDIA device plugin concern. Option D is wrong because the Azure portal AKS node pool properties expose VM size and scaling settings but do not provide a UI for NVIDIA device plugin time-slicing profiles — this must be done via Kubernetes manifests (ConfigMap + daemonset patch).

203
MCQmedium

Your data science team uses Azure Machine Learning notebooks. To prevent data exfiltration, you need to ensure that users cannot download datasets or trained model artifacts directly from the workspace to their local corporate laptops. Which feature should you configure?

A.Using Azure Front Door with Web Application Firewall disabled
B.Disabling Azure Monitor diagnostic logging
C.Workspace configured with a managed virtual network and outbound rules blocking public internet egress, plus disabled local file downloads in compute instance settings
D.Assigning the Contributor role to all external collaborators
AnswerC

Disabling local file downloads in compute instance settings directly blocks users from saving datasets or model artefacts to their laptops, satisfying the no-exfiltration constraint. The managed virtual network with outbound rules blocking public internet egress adds network-level containment, preventing alternate transfer paths from the workspace.

Why this answer

To prevent exfiltration from AML, you combine a workspace managed virtual network with outbound rules that block public internet egress, plus disabling local file downloads on compute instances. The managed VNet isolates compute and controls egress via private endpoints and FQDNs, while the compute instance setting removes the ability to download files to a local laptop. Together these enforce the no-exfiltration requirement.

Exam trap

The trap is picking a network or identity feature that sounds security-related (Front Door, RBAC) but does not actually block the data-download path; the exam expects you to know that AML managed VNet egress rules plus the compute-instance download toggle are the specific controls.

How to eliminate wrong answers

Option A is wrong because Azure Front Door with WAF disabled is a traffic-routing/CDN feature and does nothing to prevent data downloads from AML compute. Option B is wrong because disabling Azure Monitor diagnostic logging reduces audit visibility, which is the opposite of what a security control requires. Option D is wrong because granting Contributor to external collaborators expands access and increases exfiltration risk rather than preventing it.

204
MCQhard

You are designing an AI application architecture where embeddings are generated on-the-fly by an Azure Function and stored in Azure Cosmos DB for NoSQL. During peak load, the Azure Function times out due to rate limits (HTTP 429) from Azure OpenAI Service. What design pattern should you implement to make the ingestion pipeline resilient?

A.Increase the Azure Function execution timeout limit to 24 hours
B.Disable SSL verification on the Azure OpenAI client connection
C.Switch from Azure OpenAI to local text file storage
D.Implement an asynchronous message queue using Azure Service Bus to buffer ingestion requests and handle rate-limit retries
AnswerD

Azure Service Bus decouples the Function from Azure OpenAI, buffering embedding requests so bursts are absorbed and 429 responses retried with backoff rather than timing out. This satisfies the resilience constraint by smoothing peak ingestion load.

Why this answer

An asynchronous message queue (Azure Service Bus) decouples the ingestion producer from the Azure OpenAI embedding call, buffering requests during bursts and allowing retries with exponential backoff when HTTP 429 rate limits occur. This prevents Function timeouts because the Function can enqueue work quickly and a separate consumer processes at a controlled rate, absorbing peak load without dropping data.

Exam trap

AI-200 often tests the misconception that increasing timeouts or scaling out compute solves rate limiting — the real fix is decoupling with a queue and implementing retry/backoff, since the bottleneck is the downstream service's quota, not your compute.

How to eliminate wrong answers

Option A is wrong because extending the Function timeout to 24 hours does not solve rate limiting — the Function will still receive 429s and hold resources idle, and 24-hour timeouts are not even supported for Consumption-plan Functions (max 10 minutes). Option B is wrong because disabling SSL verification is a security anti-pattern that exposes traffic to MITM and does nothing for rate limits. Option C is wrong because switching to local text file storage abandons the embedding pipeline entirely and does not address resilience or rate-limit handling.

205
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

206
Multi-Selectmedium

When configuring vector search in Azure AI Search, which TWO parameters must be defined when creating a vector profile? (Choose two)

Select 2 answers
A.algorithm
B.name
C.sqlConnectionString
D.vmSize
E.cosmosDatabaseName
AnswersA, B

The algorithm parameter binds the vector profile to a specific vector search algorithm configuration, such as HNSW or exhaustive KNN. This linkage determines how similarity queries execute, making algorithm one of the two mandatory parameters when creating a vector profile.

Why this answer

When creating a vector profile in Azure AI Search, the two required parameters are the profile's name and the algorithm configuration it references. Option B (name) is correct because every vector profile must have a unique name within the search index so it can be referenced by vector fields via the vectorSearchProfile property. Option A (algorithm) is correct because a vector profile must point to a configured vector search algorithm (for example, an HNSW or exhaustive KNN configuration defined in the index's algorithms collection) that determines how the vector index is built and queried.

Options C (sqlConnectionString), D (vmSize), and E (cosmosDatabaseName) are incorrect because they are unrelated to Azure AI Search vector profile definitions: sqlConnectionString and cosmosDatabaseName pertain to data source connections for indexers, and vmSize relates to compute sizing in other Azure services, not to vector profile configuration.

Exam trap

AI-200 often tests whether candidates confuse vector profile properties (name + algorithm) with unrelated service-level parameters like SKU, connection strings, or database names that appear plausible but belong to other Azure services.

207
MCQhard

You are configuring network policies in an AKS cluster to isolate your AI inference pods from other namespaces. You notice that traffic is still flowing between namespaces despite applying a NetworkPolicy. What is the most likely cause?

A.The AKS cluster was deployed with a network plugin that does not enforce Kubernetes network policies
B.Network policies require IPv6 enablement on the cluster subnet
C.Network policies apply only to ingress controllers, not pod-to-pod traffic
D.Azure Firewall is blocking the network policy controller
AnswerA

AKS with the kubenet plugin does not enforce Kubernetes NetworkPolicy objects; only Azure CNI (or Calico) provides that enforcement. Since the stem describes policies being applied yet cross-namespace traffic still flowing, the cluster's network plugin is the cause — the policy exists but nothing implements it.

Why this answer

Kubernetes NetworkPolicy enforcement in AKS depends on the CNI/network plugin. The default 'kubenet' plugin and Azure CNI without a policy engine do not enforce NetworkPolicy objects — they are accepted by the API server but silently ignored. To enforce them you must use Azure CNI with Calico, Azure NPM (Network Policy Manager), or Cilium.

This is why traffic continues to flow between namespaces despite the policy being applied.

Exam trap

AI-200 often tests that NetworkPolicy objects are only enforced when the AKS cluster uses a compatible network plugin (Calico, Azure NPM, or Cilium), so candidates who assume 'applying the YAML is enough' pick a distractor about IPv6 or ingress controllers.

How to eliminate wrong answers

Option B is wrong because NetworkPolicy is an L3/L4 construct that works fine on IPv4; IPv6 enablement is unrelated to policy enforcement. Option C is wrong because NetworkPolicy explicitly governs pod-to-pod traffic (ingress and egress selectors), not just ingress controllers. Option D is wrong because Azure Firewall operates at the subnet/VNet egress layer and does not interfere with the in-cluster NetworkPolicy controller — it cannot 'block' policy enforcement.

208
MCQmedium

You are deploying an Azure OpenAI Service resource in a secured virtual network. You need to ensure that client applications inside a peered virtual network can access the Azure OpenAI endpoint without traversing the public internet, while completely blocking public network access. Which feature should you configure?

A.Service endpoints with default deny rules on the public firewall
B.Azure Application Gateway with Web Application Firewall (WAF)
C.Azure Bastion deployed in the management subnet
D.Azure Private Link with a private endpoint for the Azure OpenAI resource
AnswerD

Correct. Private endpoints securely map the service endpoint to a private IP within your VNet and allow you to disable public access.

Why this answer

Azure Private Link with a private endpoint assigns a private IP address from your virtual network to the Azure OpenAI resource, allowing clients in peered VNets to reach the service entirely over the Microsoft backbone network. This satisfies the requirement to avoid the public internet while enabling you to set public network access to 'Disabled' on the Azure OpenAI resource. Service endpoints do not provide a private IP for the service and still route traffic through the public Azure network, so they cannot fully block public access.

Exam trap

AI-200 often tests the misconception that service endpoints provide full network isolation like Private Link, but service endpoints do not assign a private IP and still allow public endpoint exposure unless firewall rules are carefully managed.

How to eliminate wrong answers

Option A is wrong because service endpoints extend the VNet identity to the service but do not create a private IP; traffic still goes to the public endpoint, and you cannot fully disable public network access. Option B is wrong because Application Gateway with WAF is an inbound layer-7 load balancer and web firewall for your own applications, not a mechanism to privately connect to a PaaS service like Azure OpenAI. Option C is wrong because Azure Bastion provides secure RDP/SSH access to virtual machines, not private connectivity to Azure OpenAI endpoints.

209
Multi-Selecthard

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

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

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

Why this answer

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

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

Exam trap

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

210
MCQmedium

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

211
MCQeasy

Which type of registry is most suitable for storing images that are shared across an entire organization?

A.Docker Hub (Free).
B.GitHub Container Registry.
C.Local hard drive.
D.Azure Container Registry.
AnswerD

Azure Container Registry provides a private, organisation-scoped registry with Microsoft Entra ID authentication, role-based access control and geo-replication, letting teams across the organisation pull shared images. This satisfies the stem's requirement for organisation-wide image sharing.

Why this answer

Azure Container Registry (ACR) is the Azure-native private registry designed for organization-wide image sharing. It supports Azure RBAC, Microsoft Entra ID authentication, geo-replication, private endpoints, and integration with AKS, Container Apps, and ACI, making it the correct choice for enterprise-scale image distribution.

Exam trap

The trap here is assuming any container registry works for enterprise sharing; AI-200 expects you to recognize that only ACR provides Azure-native RBAC, private networking, and geo-replication required for organization-wide use.

How to eliminate wrong answers

Option A is wrong because Docker Hub Free is a public registry with rate limits, no enterprise RBAC, and no private networking, so it is unsuitable for organization-wide private image sharing. Option B is wrong because GitHub Container Registry is tied to GitHub identities and lacks the deep Azure RBAC, private endpoint, and geo-replication integration that enterprise Azure workloads require. Option C is wrong because a local hard drive is not a registry at all and cannot serve images to distributed compute.

212
Multi-Selectmedium

Your organization wants to ensure that all Azure AI development follows strict security and observability standards. Which TWO of the following practices should be enforced across teams? (Choose two)

Select 2 answers
A.Disable all monitoring to reduce cloud resource costs.
B.Use shared root passwords for all virtual machines.
C.Require Application Insights integration on all deployed web and AI applications.
D.Mandate managed identities for all service-to-service authentication.
E.Allow developers to store production database passwords in public README files.
AnswersC, D

Application Insights captures request traces, dependency calls, exceptions and latency telemetry, directly satisfying the observability standard. Without it, teams cannot detect failures or monitor AI endpoint performance, so enforcing integration gives continuous visibility across deployed web and AI workloads.

Why this answer

Option C is correct because Application Insights provides the telemetry, distributed tracing, and logging needed to meet observability standards for deployed web and AI applications, enabling monitoring of requests, dependencies, and failures. Option D is correct because managed identities let Azure services authenticate to resources such as Key Vault, Storage, and Azure OpenAI without storing credentials in code, which directly enforces strict security standards for service-to-service authentication. Option A is wrong because disabling monitoring removes the observability required by the scenario and undermines incident detection and diagnostics.

Option B is wrong because shared root passwords eliminate accountability and violate least-privilege and credential-hygiene principles. Option E is wrong because storing production database passwords in public README files exposes secrets and is a severe security violation.

213
MCQhard

You are configuring data ingestion into an Azure AI Search index using an Azure AI Search indexer. The source data resides in Azure Blob Storage and consists of PDF documents. You want to chunk the documents and generate embeddings during ingestion without writing custom orchestration code. Which feature should you configure?

A.Azure Data Factory mapping data flows with vector transformations
B.A custom WebJob running LangChain
C.Cosmos DB change feed triggers
D.Integrated vectorization with built-in document splitting and vectorizer skillset configuration
AnswerD

Integrated vectorization combines a document-cracking indexer, a built-in text split skill for chunking, and an embedding skill wired to a vectorizer, so PDFs are chunked and embedded during ingestion. This satisfies generating embeddings without custom orchestration code.

Why this answer

Integrated vectorization is a native Azure AI Search indexer capability that combines a document-cracking skill (e.g., Document Extraction), a Text Split skill for chunking, and an AzureOpenAIEmbeddingSkill for embedding generation — all wired together through a skillset attached to the indexer. It also supports the index projection to map chunked content and vectors into the target index without any external orchestration code. This directly satisfies the requirement of chunking PDFs and generating embeddings during ingestion with no custom code.

Exam trap

AI-200 often tests the misconception that you must write custom code (LangChain, ADF, Functions) to chunk and embed documents, when integrated vectorization with a skillset is the managed, no-code answer.

How to eliminate wrong answers

Option A is wrong because Azure Data Factory mapping data flows do not natively produce Azure AI Search vector fields or call embedding models as part of the indexer pipeline — you would still need custom code and the result would not be an Azure AI Search indexer. Option B is wrong because a custom WebJob running LangChain is exactly the kind of custom orchestration code the question says to avoid, and it bypasses the managed indexer/skillset model. Option C is wrong because Cosmos DB change feed triggers are unrelated to Blob Storage ingestion and would require custom code to chunk and embed documents.

214
MCQhard

An Azure Machine Learning model is deployed to a Kubernetes cluster. Users report intermittent 503 errors. You suspect the underlying compute nodes are overloaded. Where should you look first to correlate these errors with infrastructure health?

A.Azure Key Vault audit logs.
B.Log Analytics Workspace 'AppRequests' table.
C.Container Insights in Azure Monitor.
D.Azure Machine Learning studio 'Endpoints' monitoring tab.
AnswerC

Container Insights collects node-level CPU, memory and disk pressure plus container restart and eviction signals from the Kubernetes cluster, correlating them with pod failures. That infrastructure telemetry reveals overloaded nodes behind the intermittent 503 responses.

Why this answer

Container Insights (part of Azure Monitor) provides integrated monitoring for AKS, allowing you to correlate pod restarts and node resource exhaustion with application errors.

215
MCQhard

You are managing an Azure Cosmos DB for NoSQL account that stores vector embeddings. You need to query the database using the VectorDistance function to find the top 10 most similar items to a given vector. The container has a vector index configured. Which query syntax should you use?

A.SELECT * FROM c WHERE VectorDistance(c.embedding, @queryVector) > 0.8
B.SELECT TOP 10 * FROM c ORDER BY VectorDistance(c.embedding, @queryVector)
C.SELECT TOP 10 * FROM c WHERE VectorDistance(c.embedding, @queryVector) ORDER BY c.id
D.SELECT * FROM c ORDER BY VectorDistance(c.embedding, @queryVector) OFFSET 0 LIMIT 10
AnswerB

In Cosmos DB for NoSQL, the VectorDistance function computes the similarity between a stored vector and a query vector. To retrieve the top N most similar items, you use ORDER BY VectorDistance(...) and specify the number of results with TOP. This query leverages the vector index for efficient approximate nearest neighbor search. The syntax is correct and directly addresses the requirement.

Why this answer

To retrieve the top N most similar items using vector search in Cosmos DB for NoSQL, you must use the ORDER BY clause with the VectorDistance function and limit the results with TOP. This allows the query engine to use the vector index to efficiently find the nearest neighbors. The other options either lack ordering, use invalid syntax, or do not limit results correctly.

Exam trap

The trap here is using a WHERE clause with VectorDistance instead of ORDER BY, which is a common mistake for those familiar with traditional similarity search.

216
Multi-Selecteasy

Your team is evaluating Azure Container Apps versus Azure Kubernetes Service (AKS) for hosting containerized AI workloads. Which TWO characteristics are advantages of Azure Container Apps over standard AKS? (Choose two.)

Select 2 answers
A.Requirement to manage custom CNI overlay networking routing tables manually
B.Simplified container management without direct exposure or management of Kubernetes master nodes
C.Mandatory manual configuration of KEDA controllers and Ingress controllers
D.Built-in support for scaling automatically down to zero replicas when idle
E.Complete low-level administrative access to kernel modules and cluster root certificates
AnswersB, D

Azure Container Apps abstracts the Kubernetes control plane entirely, so teams deploy containers without provisioning, patching or paying for master nodes. This satisfies the stem's advantage criterion by removing cluster infrastructure management that standard AKS requires.

Why this answer

Option B is correct because Azure Container Apps is a serverless, fully managed container platform built on Kubernetes and KEDA, so the underlying Kubernetes control plane (master nodes) is abstracted away and never exposed to the customer for patching or management, unlike AKS where you are responsible for node pools and cluster operations. Option D is correct because Container Apps natively supports scale-to-zero via its built-in KEDA-based scaling rules, meaning idle workloads consume no compute and incur no cost, whereas standard AKS requires configuring cluster autoscaler or KEDA manually and typically keeps at least one node running. Option A is incorrect because Container Apps does not require you to manage CNI overlay routing tables; that is a low-level networking task associated with self-managed Kubernetes or advanced AKS CNI configurations.

Option C is incorrect because KEDA and ingress are built into Container Apps and configured declaratively, not mandatory manual controller installations. Option E is incorrect because Container Apps deliberately restricts low-level administrative access, including kernel modules and root certificates, which is the opposite of an advantage over AKS.

Exam trap

AI-200 often tests the misconception that Container Apps is 'AKS with a nicer UI' — candidates pick answers implying manual KEDA/ingress setup, which is exactly what Container Apps removes.

217
Multi-Selectmedium

You are designing an MLOps pipeline on Azure Kubernetes Service (AKS) for a computer vision model. You need to configure GPU sharing among multiple inference pods on the same node to optimize cost. Which TWO actions should you take? Each correct answer presents part of the solution.

Select 2 answers
A.Set the pod priority class to system-node-critical.
B.Enable GPU time-slicing or NVIDIA Multi-Instance GPU (MIG) configuration.
C.Deploy the KEDA scaler with an Azure Queue trigger.
D.Configure the Azure CNI plugin for dynamic IP allocation.
E.Install the NVIDIA GPU Operator on the AKS cluster.
AnswersB, E

Time-slicing lets several pods share one physical GPU by interleaving execution, while MIG partitions the GPU into isolated instances with dedicated memory. Either mechanism satisfies the stem's requirement to share a single node's GPU across multiple inference pods and reduce cost.

Why this answer

Option B is correct because GPU sharing on AKS is achieved through NVIDIA's time-slicing or Multi-Instance GPU (MIG) configuration, which partitions a single physical GPU so multiple inference pods can run concurrently on the same node, directly reducing cost. Option E is correct because the NVIDIA GPU Operator automates the deployment and lifecycle of the GPU device plugin, drivers, container runtime, and related components on AKS, which is a prerequisite for enabling and managing time-slicing or MIG configurations. Option A is incorrect because a system-node-critical priority class only affects scheduling priority and eviction behavior; it does not enable GPU sharing.

Option C is incorrect because KEDA with an Azure Queue trigger provides event-driven autoscaling and has nothing to do with partitioning or sharing a GPU among pods. Option D is incorrect because Azure CNI dynamic IP allocation addresses pod IP address management and networking, not GPU resource sharing.

Exam trap

AI-200 often tests the misconception that autoscaling or networking features can enable GPU sharing, when in fact GPU sharing requires specific NVIDIA operator and device plugin configurations.

218
Multi-Selecthard

You are investigating performance degradation in an Azure Machine Learning inference pipeline. Which TWO of the following steps are appropriate for diagnosing the bottleneck? (Choose TWO)

Select 2 answers
A.Change the SKU of the underlying compute cluster to a lower tier.
B.Restart the Azure Machine Learning workspace to clear cache.
C.Use Application Insights to examine the 'Dependencies' and 'Requests' logs for duration outliers.
D.Delete and recreate the deployment without checking logs.
E.Review the 'Logs' tab in the Azure Machine Learning endpoint overview to check for container-level errors.
AnswersC, E

Application Insights correlates the inference endpoint's incoming Requests with outbound Dependencies, exposing per-call duration outliers across the pipeline's stages. This directly satisfies the stem's need to locate where latency accumulates, since the dependency timeline isolates whether the model scoring call or an upstream service causes the degradation.

Why this answer

Option C is correct because Application Insights is the standard Azure Monitor integration for Azure Machine Learning online endpoints and deployments, and its 'Requests' and 'Dependencies' tables capture per-call duration, response codes, and dependency latency, which lets you pinpoint duration outliers and identify whether the bottleneck is in the scoring script or a downstream dependency. Option E is correct because the endpoint's 'Logs' tab surfaces the container logs (from the scoring script and inference server, e.g., gunicorn/flask or the azureml-inference-server) where errors, timeouts, and OOM or model-loading failures appear, directly revealing container-level causes of degradation. Option A is wrong because downgrading the compute SKU reduces CPU/GPU/memory resources and would worsen performance rather than diagnose the bottleneck.

Option B is wrong because there is no supported operation to 'restart' an Azure Machine Learning workspace to clear cache, and doing so would not produce diagnostic data. Option D is wrong because deleting and recreating a deployment destroys the existing logs and telemetry needed for root-cause analysis and does not constitute a diagnostic step.

219
MCQhard

You are debugging a Python application integrated with Application Insights. You notice that custom telemetry events generated in a background worker thread are not appearing in Application Insights. What is the most likely cause of this issue?

A.Log Analytics ingestion rate limiting always drops multi-threaded telemetry
B.The application terminated or the worker thread exited before the telemetry client buffer was flushed
C.Application Insights automatically blocks all telemetry generated outside of HTTP request threads
D.The instrumentation key was incorrectly formatted as a GUID
AnswerB

The TelemetryClient buffers telemetry in memory and transmits asynchronously. If the worker thread exits or the process terminates before that buffer flushes, queued custom events are discarded and never reach Application Insights. This directly explains the missing events, satisfying the stem's background-thread constraint.

Why this answer

The Application Insights Python SDK buffers telemetry in memory and sends it asynchronously in batches. If the background worker thread exits or the application terminates before the buffer is flushed, the queued telemetry events are lost and never reach Application Insights. This is the most common cause of missing custom events from short-lived threads.

Exam trap

AI-200 often tests the misconception that telemetry is sent immediately upon track_event(), when in reality it is buffered and can be lost if the process exits before flushing.

How to eliminate wrong answers

Option A is wrong because Log Analytics ingestion rate limiting does not specifically target multi-threaded telemetry; it applies uniformly and would not selectively drop background thread events. Option C is wrong because Application Insights does not block telemetry based on thread type; it accepts telemetry from any thread as long as the SDK is used correctly. Option D is wrong because an incorrectly formatted instrumentation key would cause all telemetry to fail, not just background thread events, and the SDK would typically log an error.

220
Multi-Selectmedium

When managing Azure Container Registry (ACR), administrators can use ACR Tasks to automate tasks. Which TWO scenarios are valid use cases for ACR Tasks? (Choose two.)

Select 2 answers
A.Triggering container image rebuilds automatically when a base image is updated
B.Providing a managed Kubernetes API control plane
C.Executing automated container vulnerability scans directly inside registry storage
D.Running a persistent, multi-node enterprise database cluster inside ACR
E.Automatically building container images when code is committed to a GitHub repository
AnswersA, E

ACR Tasks supports base image update triggers, monitoring the registry for changes to a dependent base image and automatically rebuilding the derived image. This satisfies the stem's automation requirement, removing manual rebuild intervention when upstream base images change.

Why this answer

Option A is correct because ACR Tasks supports base image update triggers, which automatically rebuild dependent images when the base image in the same or another registry is updated, keeping images patched and current. Option E is correct because ACR Tasks provides source code triggers, including GitHub commit and pull request triggers, that automatically build and push container images when code changes are committed. Option B is incorrect because a managed Kubernetes API control plane is provided by Azure Kubernetes Service (AKS), not ACR.

Option C is incorrect because ACR Tasks builds and runs container workloads; vulnerability scanning is provided by Microsoft Defender for Containers or third-party integrations, not by executing scans inside registry storage. Option D is incorrect because ACR is a container image and artifact registry, not a platform for running persistent multi-node database clusters.

Exam trap

AI-200 often tests the confusion between ACR Tasks (build automation) and Defender for Containers (vulnerability scanning), causing candidates to pick scanning as an ACR Tasks use case.

221
Multi-Selecthard

You are designing a disaster recovery and backup strategy for Azure Cosmos DB for NoSQL storing vector embeddings. Which THREE backup options or capabilities are available? (Choose three)

Select 3 answers
A.Restoring backed-up data to a new Azure Cosmos DB account
B.Direct SQL Server .bak file restoration
C.Periodic backup mode with customizable retention and backup intervals
D.Continuous backup mode with point-in-time restore (up to 30 days)
E.Manual file export via FTP into local VM storage
AnswersA, C, D

Azure Cosmos DB restores backups only into a new account, not in place over the existing one. This capability satisfies the stem's disaster recovery requirement by letting you recover vector embedding data into a fresh account after corruption or loss.

Why this answer

Option A is correct because Azure Cosmos DB restore operations always create a new account (or restore into a new account) rather than overwriting the existing account, which is the standard mechanism for both periodic and continuous backup restores. Option C is correct because the periodic backup mode supports configurable backup intervals and retention periods (with defaults of every 4 hours and 2 copies retained, extendable via support), letting you tailor the schedule to your RPO needs. Option D is correct because continuous backup mode enables point-in-time restore (PITR) for the last 30 days (or 7 days in some configurations), which is ideal for protecting vector embedding data against accidental deletes or corruption.

Option B is not applicable because Cosmos DB for NoSQL is not SQL Server and does not use .bak files or native SQL Server restore tooling. Option E is not a supported capability because Cosmos DB does not provide FTP-based manual file export into local VM storage as a backup mechanism.

Exam trap

AI-200 often tests the misconception that Cosmos DB backups can be restored in place or exported as files; in reality, all restores target a new account and use service-native formats, not SQL Server .bak or FTP exports.

222
MCQhard

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

223
MCQeasy

Which Azure AI Search API parameter allows you to specify a vector query alongside traditional keyword search terms when executing a hybrid search?

A.vectorQueries
B.embeddingQuery
C.knnQuery
D.vectorSearchParam
AnswerA

The vectorQueries parameter carries the vectorised query alongside search text, letting the engine run keyword and similarity ranking together in one hybrid request. Without it, only keyword matching occurs, so the semantic half of the hybrid constraint in the stem is unmet.

Why this answer

In the Azure AI Search REST API and SDKs, the 'vectorQueries' array is the parameter that carries one or more vector query definitions alongside the traditional 'search' text parameter, enabling hybrid search. Each entry in vectorQueries specifies the vector value (or a reference to a vector field), the k-nearest neighbors count, and optional filters. When both 'search' and 'vectorQueries' are present in the same request, Azure AI Search performs hybrid ranking that fuses keyword BM25 scores with vector similarity scores.

Exam trap

AI-200 often tests exact API parameter names, so candidates pick plausible-sounding but nonexistent parameters like 'knnQuery' or 'embeddingQuery' instead of the real 'vectorQueries' array.

How to eliminate wrong answers

Option B is wrong because 'embeddingQuery' is not a valid Azure AI Search API parameter; embeddings are supplied as raw vector arrays inside vectorQueries, not via a parameter named embeddingQuery. Option C is wrong because 'knnQuery' is not the actual parameter name — while the underlying operation is k-nearest neighbor search, the API exposes it through vectorQueries with a 'k' property, not a top-level knnQuery field. Option D is wrong because 'vectorSearchParam' does not exist in the API; vector search configuration is defined in the index schema (vectorSearch profile) and invoked via vectorQueries at query time.

224
Multi-Selectmedium

Which THREE features are common to both Azure AI Search and Azure Cosmos DB for NoSQL when performing vector search?

Select 3 answers
A.Ability to filter results based on non-vector document properties.
B.Support for semantic re-ranking (Semantic Ranker).
C.Support for HNSW indexing algorithms.
D.Automatic translation of SQL to Vector queries.
E.Similarity search based on vector distance metrics.
AnswersA, C, E

Both services support pre-filtering on scalar metadata alongside vector similarity queries, satisfying the requirement for narrowing results by non-vector document properties. Azure AI Search applies OData filter expressions; Cosmos DB for NoSQL uses SQL WHERE clauses on indexed fields. This shared capability distinguishes them from services lacking integrated metadata filtering during vector search.

Why this answer

Option A is correct because both Azure AI Search (via OData filter expressions in the query) and Azure Cosmos DB for NoSQL (via a WHERE clause on non-vector fields in the VectorDistance query) allow pre-filtering results on scalar/non-vector document properties. Option C is correct because both services support HNSW (Hierarchical Navigable Small World) as an approximate nearest neighbor indexing algorithm for vector fields. Option E is correct because both platforms perform similarity search by computing vector distance metrics such as cosine, dot product, or Euclidean distance.

Option B is incorrect because Semantic Ranker is a feature exclusive to Azure AI Search and is not available in Cosmos DB for NoSQL. Option D is incorrect because neither service automatically translates SQL into vector queries; Cosmos DB uses its own SQL-like syntax with the VectorDistance function, and Azure AI Search uses its own query DSL, so no such automatic translation exists.

Exam trap

AI-200 often tests whether candidates over-generalize service-specific features (like Semantic Ranker or SQL-to-vector translation) as shared across Azure AI Search and Cosmos DB vector search.

225
MCQmedium

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

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

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

Why this answer

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

This ensures consistency across multiple entities within a single transaction.

Exam trap

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

How to eliminate wrong answers

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

Page 2

Page 3 of 6

Page 4

All pages