Free Microsoft AI-200 Practice Test Questions and Answers (2026)

In the Microsoft.Azure.ServiceBus SDK, after a SubscriptionClient is created and initialized, it does not automatically start consuming messages. You must explicitly register a message handler by calling the RegisterMessageHandler method. This method sets up the asynchronous callback mechanism required to continuously listen for, receive, and process messages from the Service Bus subscription.

A. The scenario explicitly states that the subscription client object is already created and initialized, making this instantiation step redundant.

C. Service Bus subscriptions are created with a default TrueFilter rule that accepts all messages, so manually adding this rule is unnecessary.

D. Calling CloseAsync terminates the client connection to the Service Bus, which would completely prevent the application from receiving any messages.

1. Microsoft Learn

"Receive messages from a Service Bus subscription"

Section: Register message handler.

2. Microsoft Learn

"Azure Service Bus messaging overview"

Section: Topics and subscriptions.

GitHub Actions is the best fit because it provides an automated, version-controlled CI/CD pipeline for Azure Functions. It can build and deploy Function Apps from a repository and can also deploy declarative infrastructure such as ARM or Bicep templates as part of the workflow. Local Git, Core Tools, and Azure CLI are useful deployment or management tools, but they are not themselves full version-controlled automation pipelines.

A. Local Git deploys code from a Git repo but does not provide a full automated CI/CD pipeline with declarative infrastructure stages.

C. Azure Functions Core Tools is mainly for local development, testing, and command-line deployment, not pipeline orchestration.

D. Azure CLI can deploy resources but is a command-line tool, not a version-controlled CI/CD pipeline by itself.

- Microsoft Learn

“Continuous delivery by using GitHub Actions

” Azure Functions documentation

sections “Create a GitHub Actions workflow” and “Deploy to Azure Functions.”

- Microsoft Learn

“Deploy Azure Functions using GitHub Actions

” sections “Workflow file” and “Build and deploy.”

- Microsoft Learn

“Deploy Bicep files by using GitHub Actions

” sections “Create workflow” and “Deploy Bicep file.”

- Microsoft Learn

“Azure Functions Core Tools reference

” section “func azure functionapp publish.”

Application Insights, a feature of Azure Monitor, natively supports distributed tracing across multiple Azure services (including Functions, AKS, and Cosmos DB) using OpenTelemetry. By instrumenting all services with OpenTelemetry SDKs, telemetry data is automatically enriched with a common operationId. This shared identifier allows Azure Monitor to stitch together the end-to-end transaction flow. You can then use Kusto Query Language (KQL) in Log Analytics to query, correlate, and visualize traces, metrics, and logs across all

B. Timestamp-based manual correlation is unreliable and does not provide true distributed tracing or dependency correlation.

C. Azure Monitor Agent collects host telemetry, but it does not automatically provide application-level distributed traces without instrumentation.

D. Monitoring only Azure Functions and AKS pod events does not trace request flow through Cosmos DB and other dependencies.

- Microsoft Learn

“Azure Monitor OpenTelemetry Distro

” sections “What is the Azure Monitor OpenTelemetry Distro?” and “Supported telemetry types.”

- Microsoft Learn

“Application Insights telemetry data model

” sections “Request telemetry” and “Dependency telemetry.”

- Microsoft Learn

“Telemetry correlation in Application Insights

” sections “Data model for telemetry correlation” and “Operation ID.”

- Microsoft Learn

“Analyze monitoring data with Kusto Query Language

” sections “Application Insights logs” and “Cross-resource queries.”

The solution does not meet the goal. A standard Azure Event Grid custom topic has a hard limit of 500 event subscriptions per topic. Therefore, creating an event subscription for each customer on a single custom topic cannot scale to meet the requirement of "thousands of customers." The correct architectural solution is to use Azure Event Grid Domains, which provide a single publishing endpoint and support up to 100,000 topics (allowing one topic per customer) to handle large-scale multi-tenant scenarios.

A. The solution is incorrect because a single custom topic is limited to 500 subscriptions, which cannot support thousands of customers, and it lacks multi-tenant isolation.

1. Microsoft Learn

"Understand Event Domains for managing Event Grid topics"

Section: Event Domains overview.

2. Microsoft Learn

"Azure subscription and service limits

quotas

and constraints"

Section: Azure Event Grid limits.

To test a new revision without affecting production traffic, configure the container app to use Multiple revision mode. Single revision mode automatically routes all traffic to the latest deployed revision upon readiness, whereas Multiple revision mode supports the concurrent activation of multiple versions. This enables direct access to new revisions via specific endpoints without shifting primary ingress traffic. To allocate a specific percentage of incoming requests to a secondary version (e.g., 20%), configure Traffic splitting. This feature requires Multiple revision mode and allows the proportional distribution of HTTP traffic among active revisions to facilitate A/B testing or blue-green deployments. "Traffic isolation" is not a valid revision management configuration in Azure Container Apps.

Microsoft Learn. (2025). Traffic splitting in Azure Container Apps. Section: Update existing revision. https://learn.microsoft.com/en-us/azure/container-apps/traffic-splitting

Microsoft Learn. (2025). Update and deploy changes in Azure Container Apps. Section: Revision modes / Work with multiple revisions. https://learn.microsoft.com/en-us/azure/container-apps/revisions

To receive messages from an Azure Service Bus queue using modern Azure SDKs, a specific initialization sequence is required to establish connections and configure the event-driven processing loop.

First, instantiate a ServiceBusClient to authenticate and establish a connection to the Service Bus namespace. Second, use this client to create a ServiceBusProcessor scoped to the specific target queue. Third, before the processor can consume messages, you must register event handlers (e.g., ProcessMessageAsync and ProcessErrorAsync) to define the business logic for incoming messages and connection errors. Finally, start the message processor to initiate the asynchronous message pump. Dead-lettering a message is an operational action executed within the message handler itself, not a configuration step.

Microsoft Learn. (2023). Quickstart: Send and receive messages from an Azure Service Bus queue (.NET). Azure Service Bus Documentation. Section: "Receive messages". Retrieved from Microsoft official documentation. This document details the architectural sequence of initializing the ServiceBusClient, creating the ServiceBusProcessor, hooking up the ProcessMessageAsync and ProcessErrorAsync handlers, and invoking StartProcessingAsync().

Microsoft Learn. (2023). Azure.Messaging.ServiceBus Namespace. Azure SDK for .NET. Section: "ServiceBusProcessor Class". Retrieved from Microsoft official documentation. Details the lifecycle and required handler registration before calling the start method.

In a newly provisioned Azure subscription, you must first register the Event Grid resource provider (Microsoft.EventGrid) to enable the service. Once registered, the next step is to create a custom topic. A custom topic provides the endpoint where your AI application will publish its custom inference events. Finally, you create an event subscription attached to the custom topic. The event subscription is responsible for defining the downstream processor (the endpoint) and can include specific filtering rules to ensure only the high-confidence events are routed appropriately. Domains are unnecessary here as they are intended for multi-tenant architectures, and partner topics are reserved for third-party SaaS integrations.

Microsoft Learn: Azure Event Grid - Quickstart: Route custom events to web endpoint:

Section: "Register Event Grid resource provider". This document confirms that for newly provisioned subscriptions, registering the Microsoft.EventGrid provider is the mandatory prerequisite step before creating topics.

Microsoft Learn: Azure Event Grid - Custom topics in Azure Event Grid:

Section: "Overview". This section details that application-generated events (like custom AI inference outputs) are handled by publishing to an Event Grid custom topic.

Microsoft Learn: Azure Event Grid - Event filtering for Event Grid subscriptions:

Section: "Advanced filtering". This section explains how event subscriptions are applied to topics to route data to downstream processors and how advanced filters evaluate event payload data (e.g., confidence scores) to control routing.

To securely deploy a private container image from Azure Container Registry (ACR) to Azure App Service without relying on static credentials, you must leverage Microsoft Entra ID (formerly Azure Active Directory) via a Managed Identity.

By enabling a system-assigned or user-assigned managed identity on the App Service and granting it the AcrPull role scoped to the registry, the App Service can authenticate directly with ACR. This completely eliminates the need to enable the admin user on the ACR or store static passwords in the App Service application settings (e.g., DOCKER_REGISTRY_SERVER_PASSWORD), thereby meeting both requirements of the scenario securely.

Microsoft Learn: Azure App Service documentation

Document: "Migrate custom software to Azure App Service using a custom container" / "Use managed identity for image pull"

Section: Configure managed identity to pull from Azure Container Registry.

Detail: Officially states that enabling a managed identity and assigning the AcrPull role is the recommended method to avoid using the admin credentials for continuous deployments.

Microsoft Learn: Azure Container Registry documentation

Document: "Authenticate with managed identity - Azure Container Registry"

Section: Authenticate using a managed identity.

Detail: Confirms that the AcrPull built-in role provides the exact least-privilege permissions required to pull images without needing static registry passwords embedded in configuration files or code.

Yes: The Python code uses r.hset() on line 10. In Redis, HSET is used to set the string value of a hash field. Therefore, the embedding is being stored as a field ("embedding") within a hash map stored at the key "doc:1".

No: Merely storing vector bytes in a hash field does not enable similarity search. To perform vector similarity searches in Redis (using the RediSearch module), you must explicitly create an index on the data using the FT.CREATE command, defining a schema that specifies the vector field, dimensionality, and distance metric (e.g., COSINE, L2). The provided code lacks this index creation step.

Yes: The code uses r.expire("doc:1", 600) on line 11. The EXPIRE command in Redis sets a timeout on a key in seconds. 600 seconds is mathematically equivalent to exactly 10 minutes.

Redis Documentation (HSET): Redis command reference for HSET, detailing how it sets fields in the hash stored at a key. (Available at redis.io/commands/hset)

Redis Documentation (Vector Similarity): Redis documentation on Vector Similarity Search, which explicitly states that an index must be created (FT.CREATE) over hashes or JSON documents to query vectors. (Available at redis.io/docs/interact/search-and-query/search/vectors)

Redis Documentation (EXPIRE): Redis command reference for EXPIRE, confirming the timeout parameter is represented in seconds. (Available at redis.io/commands/expire)

PgBouncer is the native, built-in connection pooling solution for Azure Database for PostgreSQL designed to reduce connection overhead and manage database connections efficiently. For high-concurrency workloads where applications rapidly open and close connections for individual requests, Transaction pooling mode is the optimal configuration. In this mode, PgBouncer returns the database connection to the pool immediately after a transaction completes, rather than locking it to the client for the entire duration of the session. This maximizes connection reuse, significantly increases the number of concurrent requests the system can handle, and prevents connection exhaustion.

Microsoft Learn. "PgBouncer in Azure Database for PostgreSQL - Flexible Server." Azure Architecture and Database Configuration Documentation. Section: Pooling modes. (Details the advantages of transaction pooling for high-throughput, short-lived connection scenarios).

Microsoft Learn. "Performance best practices for Azure Database for PostgreSQL." Azure PostgreSQL Performance Tuning. Section: Connection pooling. (Recommends PgBouncer and Transaction mode to solve connection limit failures during peak traffic).