This post/practice exam is a part of the AI-200: Developing AI Cloud Solutions on Azure  Exam Prep Hub.

Section 1 — Develop Containerized Solutions on Azure

Question 1 — Scenario: Container Apps Revision Strategy

A company hosts an AI inference API in Azure Container Apps.

The current production revision is v17. A new revision, v18, contains a significant change to the inference pipeline.

The development team wants to:

• deploy v18 without immediately sending all users to it,
• send 5% of production traffic to v18,
• monitor the new revision,
• increase traffic gradually,
• immediately return traffic to v17 if errors increase.

No changes should be made to the container image itself.

Which approach should you use?

A. Configure a KEDA scaler to maintain 5% of replicas on v18.

B. Create a new Container Apps revision and use revision traffic splitting.

C. Create a new ACR repository for v18 and configure both repositories as application replicas.

D. Deploy v18 as an AKS Deployment and use a Service to distribute traffic.

Answer: B

Explanation

Container Apps revisions are designed for versioned application deployments. Multiple revisions can coexist, and traffic can be assigned between revisions.

KEDA controls scaling, not deployment traffic percentages. ACR repositories store images, while moving the workload to AKS would introduce an unnecessary architecture change.

A particularly important distinction for AI-200 is:

Revision management controls application versions and traffic; KEDA controls scaling.

The current study guide explicitly calls out Container Apps environments, revision management, and KEDA event-driven scaling.

Question 2 — Scenario: ACR Image Lifecycle

A company has an ACR repository containing:

ai-api:1.0
ai-api:1.1
ai-api:1.2
ai-api:latest

Production deployments must always use an immutable version rather than a mutable tag such as latest.

The deployment pipeline should also be able to identify exactly which image version was deployed.

Which approach is best?

A. Deploy ai-api:latest and record the deployment timestamp.

B. Deploy ai-api:1.2 and use immutable image identification such as its digest for deployment traceability.

C. Rebuild the image every time the application starts.

D. Store the Dockerfile in Azure Key Vault and rebuild the image during deployment.

Answer: B

Explanation

A versioned tag is preferable to latest for predictable deployments, and an image digest provides stronger immutability because it identifies the exact image content.

Using latest makes it possible for the same deployment configuration to resolve to different image content later.

The question tests the distinction between image versioning and mutable deployment references, both relevant to the ACR portion of AI-200. The study guide explicitly includes generating, storing, versioning, and managing container images in ACR.

Question 3 — Scenario: KEDA Scaling

An AI document-processing application runs in Azure Container Apps.

The application consumes messages from a queue.

During peak periods:

Queue messages:      18,000
CPU utilization:       22%
Memory utilization:    31%
Application replicas:    2

Messages are waiting several minutes before being processed.

The application currently scales based only on CPU utilization.

What should you change?

A. Increase the CPU limit for each replica.

B. Configure KEDA-based event-driven scaling using the queue workload.

C. Configure a Container Apps revision with 100% traffic.

D. Move the queue data into ACR.

Answer: B

Explanation

CPU is not the appropriate workload signal here. The actual bottleneck is the growing queue.

KEDA allows Container Apps to scale according to an external event source, making it appropriate for queue-driven workloads.

This is exactly the type of diagnostic reasoning that AI-200 expects: identify the workload signal rather than automatically scaling based on CPU.

The current Microsoft objectives explicitly identify KEDA event-driven scaling in Container Apps.

Question 4 — Matching: Container Deployment Concepts

Match each requirement to the most appropriate capability.

Answers

• 1 → C
• 2 → A
• 3 → B
• 4 → D

Explanation

• ACR Tasks → automated image building.
• Container Apps revisions → versioned application deployments.
• KEDA → event-driven scaling.
• Kubernetes manifests → declarative AKS resource configuration.

These distinctions are explicitly reflected in the current AI-200 containerization objectives.

Question 5 — Scenario: AKS Connectivity

An AI service is deployed to AKS.

The following observations have been made:

• The Deployment reports the expected number of replicas.
• Pods are in Running state.
• Application logs show successful startup.
• Requests through the application’s public endpoint fail.
• Direct requests from within the pod to the application port succeed.

What should you investigate next?

A. The container registry’s image retention policy.

B. The Kubernetes Service, Ingress, selectors, and port mappings.

C. The application’s vector index.

D. The PostgreSQL connection pool.

Answer: B

Explanation

The evidence isolates the problem:

Container starts       ✓
Application responds   ✓
External access        ✗

Therefore, the next layer to investigate is the connectivity path between the external endpoint and the pod.

Important areas include:

• Service selectors
• Service ports
• target ports
• Ingress configuration
• ingress controller
• routing/network configuration

The AI-200 study guide specifically calls for troubleshooting AKS and Container Apps by inspecting logs, events, and end-to-end connectivity.

Question 6 — Multiple Answers

A team wants to deploy the same containerized AI API to three environments:

Development
Test
Production

Which two practices are appropriate?

A. Build separate images solely because environment configuration differs.

B. Externalize environment-specific configuration.

C. Use environment variables/application settings where appropriate.

D. Embed production secrets in the Dockerfile.

Answers: B, C

Explanation

The same image should generally be reusable across environments.

Environment-specific configuration should be supplied externally, such as through application settings/environment variables or appropriate configuration services.

Production secrets should never be embedded in the image.

Microsoft explicitly includes configuring App Service to provide environment variables and secrets in the AI-200 objectives.

Question 7 — Scenario: AKS vs. Container Apps

A company is building an AI platform with these requirements:

• Kubernetes manifests must be used.
• The team needs direct access to Kubernetes resources.
• Several specialized Kubernetes controllers will be installed.
• The team already has substantial Kubernetes operational expertise.
• Developers need Kubernetes-native workload configuration.

Which service should be selected?

A. Azure Container Apps

B. Azure App Service

C. Azure Functions

D. Azure Kubernetes Service

Answer: D

Explanation

The requirements explicitly depend on Kubernetes-native capabilities.

AKS is therefore the appropriate choice.

Container Apps provides a managed container application platform, but it intentionally abstracts away much of Kubernetes. When direct Kubernetes control is a requirement, AKS is the better fit.

The AI-200 objectives explicitly include deploying and managing AKS applications using manifest files.

Section 2 — Develop AI Solutions Using Azure Data Management Services

Question 8 — Cosmos DB Partitioning Scenario

An Azure Cosmos DB for NoSQL container stores documents for millions of customers.

The current partition key is:

/documentType

There are only a few document types, and one type contains approximately 80% of all documents.

The application experiences uneven request distribution and a heavily utilized partition.

What is the most likely underlying issue?

A. The partition key has poor cardinality and creates a hot partition.

B. The consistency level is necessarily too strong.

C. The vector embeddings are too large.

D. The container requires an Event Grid subscription.

Answer: A

Explanation

A good partition key should help distribute data and workload across logical partitions.

Using a low-cardinality property where one value dominates can result in uneven distribution and a hot partition.

This question is deliberately more architectural than simply asking which Cosmos DB query syntax to use.

Question 9 — Cosmos DB Query Optimization

A Cosmos DB query is:

SELECT *
FROM c
WHERE c.tenantId = @tenantId
  AND c.status = "Active"
  AND c.createdDate >= @date
ORDER BY c.createdDate DESC

The query executes frequently and consumes more RUs than expected.

The development team wants to investigate whether the indexing strategy matches the query workload.

What should they do?

A. Disable all indexing.

B. Examine the indexing policy and query characteristics, and optimize indexes for the actual query patterns.

C. Change the database to PostgreSQL.

D. Replace the query with an Event Grid event.

Answer: B

Explanation

Cosmos DB indexing is automatic by default, but indexing policies can be customized.

For performance-sensitive workloads, developers should understand which properties are being filtered/sorted and ensure that indexing aligns with query patterns rather than assuming that more indexing is always better.

Microsoft specifically identifies optimizing query performance and RU consumption through indexing policies and consistency levels.

Question 10 — Cosmos DB Change Feed Scenario

A document is inserted into Cosmos DB.

The application must automatically:

1. Detect the new document.
2. Generate an embedding.
3. Store the embedding.
4. Update a downstream search representation.

The application should not repeatedly query the entire container looking for new documents.

Which capability should be used?

A. Cosmos DB change feed processor

B. Cosmos DB strong consistency

C. Cosmos DB composite index

D. Redis expiration

Answer: A

Explanation

The change feed provides a mechanism for detecting changes to items.

A change feed processor can consume changes and drive downstream processing such as:

New document
     ↓
Change feed
     ↓
Embedding generation
     ↓
Vector storage

This is explicitly part of the AI-200 Cosmos DB objectives.

Question 11 — PostgreSQL Connection Optimization

An AI application creates a new PostgreSQL connection for every individual database operation.

Under heavy load, the application experiences:

• high connection counts,
• increased connection latency,
• reduced throughput.

The database itself isn’t CPU-bound.

What should the developer investigate?

A. Connection pooling and connection reuse.

B. Increasing vector dimensionality.

C. Event Grid event filtering.

D. Cosmos DB consistency.

Answer: A

Explanation

Creating and tearing down database connections repeatedly introduces overhead.

Connection pooling and connection reuse can reduce connection establishment overhead and improve throughput and latency.

The current AI-200 study guide explicitly includes connection optimization to improve throughput and reduce latency for PostgreSQL.

Question 12 — PostgreSQL Vector Search

A RAG application stores:

document_id
tenant_id
document_type
content
embedding

Users should only retrieve documents belonging to their tenant.

The application needs semantic similarity retrieval.

Which approach should be implemented?

A. Search only on content.

B. Perform vector similarity search and apply the tenant metadata filter.

C. Use PostgreSQL connection pooling as the security boundary.

D. Use vector similarity scores as authorization decisions.

Answer: B

Explanation

Vector similarity identifies semantically relevant content.

Metadata filtering constrains the candidate set:

Tenant filter
     ↓
Eligible documents
     ↓
Vector similarity
     ↓
Relevant chunks

The vector similarity score itself should not be treated as an authorization mechanism.

The AI-200 study guide explicitly includes vector similarity, semantic retrieval, RAG, and metadata filtering.

Question 13 — PostgreSQL Vector Performance

A PostgreSQL database contains millions of embeddings.

Vector searches are accurate but increasingly slow.

Telemetry shows that CPU usage is very high during vector searches, while storage I/O remains relatively low.

Which two areas should be investigated first?

A. Vector indexing strategy.

B. pgvector query strategy.

C. Event Grid retry policy.

D. Azure Key Vault secret expiration.

Answers: A, B

Explanation

High CPU during vector similarity operations points toward the computational cost of vector search.

The developer should investigate:

• the vector indexing strategy,
• the query plan,
• pgvector configuration,
• similarity-search approach,
• filtering strategy.

Microsoft explicitly identifies optimizing vector-search latency and reducing pgvector compute overhead.

Question 14 — Azure Managed Redis

An AI application uses Azure Managed Redis to cache generated answers.

The application has this requirement:

If a cached answer becomes stale, the application must not continue serving it indefinitely.

Which Redis capability directly addresses this requirement?

A. Event Grid filtering

B. Key expiration/TTL

C. Cosmos DB change feed

D. PostgreSQL pgvector

Answer: B

Explanation

Redis key expiration allows a key to automatically expire after a specified interval.

For example:

Cache answer
     ↓
TTL = 10 minutes
     ↓
Entry expires
     ↓
Application regenerates/retrieves result

The AI-200 objectives explicitly include Redis caching, expiration, and invalidation.

Question 15 — Multiple Answers: Data-Service Architecture

An AI application must support:

• semantic retrieval,
• frequently accessed results,
• relational metadata,
• millions of vector embeddings.

Which two architectural choices are reasonable?

A. PostgreSQL with pgvector can provide relational data plus vector search.

B. Redis can be used for caching frequently accessed results.

C. Key Vault should be used as the primary vector database.

D. Event Grid should replace the relational database.

Answers: A, B

Explanation

PostgreSQL with pgvector can combine relational modeling and vector search.

Azure Managed Redis can provide low-latency caching and vector-related capabilities.

Key Vault is a secret-management service, not a general-purpose vector database, and Event Grid is an event-routing service.

The current AI-200 course explicitly identifies PostgreSQL with pgvector and Azure Managed Redis as AI-oriented data services.

Section 3 — Connect to and Consume Azure Services

Question 16 — Service Bus Topic Architecture

An application publishes:

InvoiceProcessed

Three independent systems need to receive every event:

Billing Analytics
Notification Service
Audit Service

The publisher should publish the event once without knowing which consumers exist.

Which Service Bus configuration is most appropriate?

A. One queue with three consumers

B. One topic with a subscription for each consumer

C. Three queues populated manually by the publisher

D. One Redis key per consumer

Answer: B

Explanation

A Service Bus topic provides publish/subscribe semantics.

Each subscription receives its own copy of messages published to the topic.

Conceptually:

                  Topic
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
   Billing       Notify       Audit
 subscription  subscription subscription

Queues are more appropriate for competing consumers where a message should normally be processed by one consumer.

Service Bus topics, subscriptions, messages, and dead-letter handling are part of the AI-200 objectives.

Question 17 — Service Bus Message Processing

A Service Bus worker receives a message and begins processing it.

The worker crashes before successfully completing the message operation.

What is the primary purpose of Service Bus message settlement/lock semantics in this situation?

A. To allow the message to be considered successfully processed without any acknowledgment.

B. To help prevent concurrent processing and allow unsuccessful processing to be retried according to the messaging semantics.

C. To convert the message into a vector embedding.

D. To permanently delete the message when the worker crashes.

Answer: B

Explanation

Service Bus supports message-lock and settlement concepts that help coordinate message processing.

A message isn’t simply considered successfully completed because a consumer received it.

If processing fails and the message isn’t successfully completed, it can become available for redelivery according to the applicable Service Bus behavior.

This is an important distinction between receiving and successfully completing a message.

Question 18 — Service Bus Dead-Letter Scenario

An AI processing service repeatedly receives a malformed message.

The message cannot be processed successfully.

The operations team wants failed messages separated from the normal processing path so that developers can inspect them later.

What should the application use?

A. Dead-letter queue

B. Redis cache

C. Event Grid custom event

D. Cosmos DB vector index

Answer: A

Explanation

The Service Bus dead-letter queue provides a dedicated location for messages that cannot be processed successfully or meet configured dead-lettering conditions.

It prevents a permanently problematic message from continuously interfering with normal processing.

Dead-letter queue management is explicitly included in AI-200.

Question 19 — Event Grid Filtering

A custom Event Grid topic receives:

DocumentUploaded
DocumentClassified
DocumentRejected
DocumentArchived

A subscriber is responsible only for rejected documents.

Which configuration minimizes unnecessary event delivery?

A. Increase the subscriber’s CPU.

B. Configure event subscription filtering.

C. Put all events into a Redis cache.

D. Use a Service Bus dead-letter queue.

Answer: B

Explanation

Event Grid subscription filters allow a subscriber to receive only events matching specified criteria.

Filtering is preferable to delivering every event and forcing the subscriber application to discard unwanted events.

Event filtering, custom events, and retries are explicitly listed in the current AI-200 objectives.

Question 20 — Event Grid Retry Scenario

An Event Grid subscriber is temporarily unavailable.

The publisher should not have to implement its own polling loop to repeatedly check whether the subscriber has recovered.

Which capability should be relied upon?

A. Event Grid retry behavior

B. Redis TTL

C. Cosmos DB consistency

D. AKS Horizontal Pod Autoscaler

Answer: A

Explanation

Event Grid provides delivery retry behavior for events that cannot initially be delivered successfully.

The purpose is to make event delivery more resilient to temporary endpoint failures.

Retry behavior is specifically included in the AI-200 Event Grid objectives.

Question 21 — Azure Functions Binding

A Function receives an HTTP request containing a document ID.

The Function must write a message to an Azure Service Bus queue.

The developer wants to use Azure Functions integration rather than manually implementing all of the Service Bus client code.

Which capability should be used?

A. HTTP trigger only

B. Service Bus output binding

C. Cosmos DB change feed

D. Event Grid event filter

Answer: B

Explanation

The HTTP trigger initiates function execution.

A Service Bus output binding can connect the function to the queue for output.

This illustrates the important distinction:

Trigger  → causes execution
Binding  → connects execution to data/services

Microsoft explicitly includes Functions triggers and bindings in the AI-200 objectives.

Question 22 — Fill in the Blank

Complete the statement:

An Azure Functions __________ determines what event or condition causes a function to execute.

Answer: trigger

Explanation

Examples include:

• HTTP trigger
• Service Bus trigger
• Timer trigger
• Event-based triggers supported by Functions

A binding is different: it provides a declarative connection to input or output data.

Question 23 — Scenario: Choosing Between Service Bus and Event Grid

An AI platform has these two requirements:

Requirement A

A document-processing job must be placed into a durable work queue. Multiple worker instances should compete for available jobs.

Requirement B

When processing completes, multiple independent systems should be notified that the document is complete.

Which design is best?

A. Event Grid for A and Redis for B

B. Service Bus queue for A and Event Grid for B

C. Redis queue for A and Cosmos DB change feed for B

D. Event Grid for both A and B

Answer: B

Explanation

Requirement A is a work-queue scenario:

Jobs → Service Bus queue → competing workers

Requirement B is an event notification/pub-sub scenario:

Processing complete → Event Grid → multiple subscribers

The distinction between messaging and event notification is important.

Microsoft’s AI-200 course specifically teaches both message-based and event-driven architectures using Service Bus and Event Grid.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Question 24 — Key Vault and Application Identity

An Azure-hosted Function needs to retrieve a database password from Key Vault.

The security team prohibits storing a Key Vault credential in source code, configuration files, or the container image.

Which solution is most appropriate?

A. Embed the Key Vault credential in the Function package.

B. Store the password in App Configuration as plaintext.

C. Use an appropriate managed identity for the Function and grant it the required Key Vault access.

D. Put the password in an Event Grid event.

Answer: C

Explanation

A managed identity allows an Azure resource to authenticate to supported Azure services without the application having to maintain a long-lived credential for that identity.

Key Vault then remains responsible for storing the actual secret.

This follows the principle:

Application identity
        ↓
Key Vault authorization
        ↓
Secret retrieval

The AI-200 objectives explicitly include securing, rotating, and retrieving secrets using Key Vault.

Question 25 — App Configuration vs. Key Vault

An application has the following settings:

Feature:EnableSemanticCache = true
Feature:UseNewModel = false
AI:DeploymentName = gpt-production
Database:ConnectionPassword = ********

The team wants centralized configuration management while keeping secrets securely managed.

Which design is most appropriate?

A. Put all values in Key Vault.

B. Put all values in App Configuration.

C. Put non-secret configuration in App Configuration and secrets in Key Vault.

D. Put all values in environment variables inside the Docker image.

Answer: C

Explanation

App Configuration is intended for centralized application configuration.

Key Vault is intended for sensitive secrets.

Therefore:

App Configuration
 ├── feature flags/settings
 ├── deployment names
 └── other non-secret configuration
Key Vault
 └── passwords/API keys/secrets

The AI-200 study guide explicitly distinguishes the two capabilities.

Question 26 — Secret Rotation

A production AI service uses an API key stored in Key Vault.

The security team rotates the key regularly.

The development team wants the application to obtain the current secret without rebuilding or redeploying the container every time the key changes.

What design best meets the requirement?

A. Store the secret in the Dockerfile.

B. Store the secret in source control.

C. Retrieve the secret from Key Vault at runtime.

D. Put the secret into the container image during every deployment.

Answer: C

Explanation

Runtime retrieval separates the secret lifecycle from the application deployment lifecycle.

The container image remains unchanged while the secret can be rotated independently.

This is exactly the type of secret-management pattern targeted by AI-200.

Question 27 — OpenTelemetry Trace Analysis

An application exposes an HTTP endpoint.

A trace shows:

HTTP request                         6,250 ms
│
├── Function execution                120 ms
├── Service Bus send                   35 ms
├── PostgreSQL query                   95 ms
├── Cosmos DB query                    80 ms
└── External AI service             5,820 ms

The development team wants to reduce the endpoint’s response time.

What should they investigate first?

A. The external AI service call.

B. The Cosmos DB indexing policy.

C. The Service Bus queue’s dead-letter count.

D. The Docker image tag.

Answer: A

Explanation

The external AI service accounts for approximately 5.8 seconds of the 6.25-second request.

The trace therefore provides strong evidence that this dependency is the dominant contributor.

This is precisely why distributed tracing is valuable: it lets developers identify where time is being spent across service boundaries.

The AI-200 study guide specifically requires distributed tracing using OpenTelemetry SDKs.

Question 28 — KQL Interpretation

You have an AppRequests telemetry table containing:

TimeGenerated
DurationMs
Success

You need to identify the five-minute intervals during the last 30 minutes with the highest average request duration.

Which query is most appropriate?

A.

AppRequests
| where TimeGenerated > ago(30m)
| summarize AvgDuration = avg(DurationMs)
    by bin(TimeGenerated, 5m)
| top 6 by AvgDuration desc

B.

AppRequests
| top 6 by DurationMs

C.

AppRequests
| summarize count() by Success

D.

AppRequests
| project TimeGenerated, DurationMs

Answer: A

Explanation

The requirement is to:

1. Restrict data to the last 30 minutes.
2. Group records into five-minute buckets.
3. Calculate average duration for each bucket.
4. Return the highest averages.

The query accomplishes all four.

Key KQL operators:

• where → filters records.
• bin() → creates time intervals.
• summarize → aggregates.
• avg() → calculates the average.
• top → returns the highest values.

KQL analysis of logs and metrics is explicitly included in AI-200.

Question 29 — Multiple Answers: Troubleshooting

An AI application intermittently experiences slow requests.

Which two forms of telemetry would provide complementary information when diagnosing the problem?

A. Distributed traces showing the path and timing of individual requests.

B. Aggregate metrics showing latency, throughput, and error trends.

C. ACR image tags alone.

D. Dockerfile comments.

Answers: A, B

Explanation

Distributed traces answer questions such as:

“Where did this individual request spend its time?”

Metrics answer questions such as:

“Is latency increasing across the application?”

Using both provides a much stronger diagnostic picture than either alone.

OpenTelemetry distributed tracing and KQL-based analysis of logs and metrics are explicit AI-200 objectives.

Question 30 — Comprehensive Final Scenario

You are troubleshooting an AI document-processing platform:

                   HTTP API
                      │
                      ▼
              Azure Service Bus
                      │
                      ▼
             Azure Container Apps
                      │
             ┌────────┴────────┐
             ▼                 ▼
        Cosmos DB          PostgreSQL

The operations team reports:

• HTTP requests remain fast.
• The Service Bus queue backlog increases dramatically during peak periods.
• Container Apps CPU averages only 25%.
• Container Apps memory averages 35%.
• PostgreSQL latency remains normal.
• Cosmos DB RU consumption remains normal.
• Distributed traces show that once processing begins, each document is processed normally.
• The application currently uses CPU-based scaling for Container Apps.

The company wants to minimize processing delay while avoiding unnecessary compute costs.

Which two actions should you take?

A. Configure KEDA event-driven scaling based on the queue workload.

B. Increase PostgreSQL compute capacity.

C. Investigate the queue backlog as the workload signal and tune scaling thresholds accordingly.

D. Increase Cosmos DB consistency to Strong.

Answers: A, C

Explanation

The evidence strongly indicates a scaling-signal problem.

The important observations are:

Queue backlog       HIGH
CPU                 LOW
Memory              LOW
Database latency    NORMAL
Processing time     NORMAL

The processor is healthy once it receives work, but insufficient replicas are being created while work is waiting in the queue.

Therefore:

1. Use KEDA event-driven scaling based on the queue.
2. Tune the scaling configuration around the actual workload signal.

Increasing PostgreSQL capacity or Cosmos DB consistency would not address the observed bottleneck.

This scenario combines several AI-200 competencies:

• Container Apps
• KEDA
• Service Bus
• scalability
• telemetry
• troubleshooting
• architecture reasoning

The current study guide specifically identifies KEDA scaling and troubleshooting using logs, events, and end-to-end connectivity.

Go to the AI-200 Exam Prep Hub main page

This post/practice exam is a part of the AI-200: Developing AI Cloud Solutions on Azure  Exam Prep Hub.

Section 1 — Develop Containerized Solutions on Azure

Question 1 — Scenario-Based: Container Apps Revisions

A company operates an AI summarization API in Azure Container Apps.

Revision 12 is currently serving all production traffic. The development team deploys revision 13, which contains a new model-integration implementation.

The team wants to:

1. Send a small percentage of traffic to revision 13.
2. Compare its behavior with revision 12.
3. Increase traffic to revision 13 if testing is successful.
4. Roll back quickly if problems occur.

Which Azure Container Apps capability should be used?

A. KEDA scaling rules

B. Container Apps revisions and traffic splitting

C. Azure Container Registry Tasks

D. AKS Horizontal Pod Autoscaler

Answer: B

Explanation

Azure Container Apps revisions allow multiple versions of an application to coexist. Traffic can be distributed between revisions, making revisions appropriate for controlled rollouts, testing, and rollback scenarios.

KEDA addresses event-driven scaling, not deployment traffic management. ACR Tasks builds container images, while AKS-specific autoscaling mechanisms aren’t required for a Container Apps deployment.

Microsoft specifically includes Container Apps environment configuration and revision management in the AI-200 objectives.

Question 2 — Scenario-Based: ACR Tasks

A development team has the following workflow:

Git repository
      ↓
Dockerfile
      ↓
Container image
      ↓
Azure Container Registry
      ↓
Azure Container Apps

Every time a change is committed to the application’s source repository, the team wants Azure to automatically build the image and publish it to ACR.

The team does not want to maintain a build VM.

Which solution should you implement?

A. Azure Container Registry Tasks

B. Azure Functions with a timer trigger

C. Azure App Service deployment slots

D. Azure Managed Redis

Answer: A

Explanation

Azure Container Registry Tasks provide cloud-based automation for building container images and can be triggered by source-code changes.

This is preferable to creating a custom VM-based build process when the requirement is specifically automated container-image building.

ACR Tasks are explicitly included in the AI-200 containerization objectives.

Question 3 — AKS Manifest Troubleshooting

An AI application is deployed to AKS using a Kubernetes manifest.

The deployment contains:

• a Deployment
• a Service
• an Ingress

The pods are running successfully and the container logs show that the application started correctly.

However, requests sent through the public endpoint return connection errors.

Which investigation is the most appropriate next step?

A. Change the Cosmos DB consistency level.

B. Rebuild the container image using ACR Tasks.

C. Inspect the Service, Ingress, port mappings, selectors, and end-to-end network path.

D. Increase the Redis cache expiration interval.

Answer: C

Explanation

The successful pod startup and application logs indicate that the problem is probably beyond the container’s basic startup process.

The next logical layer is the connectivity path:

Internet
   ↓
Ingress
   ↓
Service
   ↓
Pod
   ↓
Container port

Incorrect selectors, ports, ingress configuration, or networking can prevent an otherwise healthy pod from receiving external requests.

Microsoft specifically includes troubleshooting AKS and Container Apps by examining logs, events, and end-to-end connectivity.

Question 4 — Multiple Answers

A company deploys an AI API to Azure Container Apps.

The application experiences sudden bursts of requests generated by a backend messaging workload. CPU utilization isn’t a reliable indicator of pending work.

Which two capabilities are relevant to designing the scaling solution?

A. KEDA event-driven scaling

B. Container Apps revision management

C. An event-based scaler that responds to the workload source

D. Azure Container Registry image versioning

Answers: A, C

Explanation

KEDA provides event-driven autoscaling and can scale applications based on external event sources.

Revision management handles versions of the application but doesn’t determine how replicas are added based on workload.

ACR image versioning manages images rather than application replica counts.

The AI-200 study guide explicitly identifies KEDA event-driven scaling in Container Apps.

Question 5 — Scenario-Based: App Service Container Configuration

A containerized AI application is deployed to Azure App Service.

The same image must be deployed to development, test, and production environments.

Each environment has a different value for:

AI_ENDPOINT
MODEL_NAME

The development team wants to use the same image in all three environments.

Which approach is most appropriate?

A. Build a different container image for every environment.

B. Store environment-specific values in the Dockerfile.

C. Supply environment-specific configuration through App Service application settings/environment variables.

D. Create a separate Azure Container Registry for each environment.

Answer: C

Explanation

Environment-specific configuration should generally be separated from the container image.

App Service can supply application settings to the container, allowing the same image to run in different environments with different configuration.

This approach improves portability and prevents configuration values from becoming embedded in the image.

Microsoft specifically identifies configuring App Service to supply environment variables and secrets as an AI-200 objective.

Question 6 — Matching: Container Technologies

Match each requirement to the best Azure capability.

Answers

• 1 → B
• 2 → A
• 3 → C
• 4 → D

Explanation

Each technology addresses a different part of the container lifecycle:

• ACR Tasks — automated container image builds.
• Container Apps revisions — versioned application deployments.
• KEDA — event-driven autoscaling.
• AKS manifests — declarative Kubernetes application configuration.

These capabilities correspond directly to the containerization objectives in the current AI-200 study guide.

Question 7 — Scenario-Based: Selecting AKS

A company has developed an AI inference platform consisting of multiple containerized components.

The architecture team requires:

• Kubernetes APIs and resource definitions
• Fine-grained Kubernetes workload configuration
• Direct control over Kubernetes networking and workloads
• The ability to manage Kubernetes resources through manifests

The team is willing to take on the additional operational responsibility associated with Kubernetes.

Which service should they select?

A. Azure Functions

B. Azure App Service

C. Azure Container Apps

D. Azure Kubernetes Service

Answer: D

Explanation

AKS is the appropriate choice when the architecture requires direct use of Kubernetes concepts, APIs, manifests, and Kubernetes workload management.

Container Apps provides a more managed abstraction over containerized application hosting and is preferable when the team doesn’t require direct Kubernetes control.

The AI-200 objectives explicitly include deploying and managing applications on AKS using manifest files.

Section 2 — Develop AI Solutions Using Azure Data Management Services

Question 8 — Cosmos DB Query Optimization

An application uses Azure Cosmos DB for NoSQL.

A query filters on:

customerId
status
createdDate

The query returns only a small number of documents, but its RU consumption is unexpectedly high.

The team discovers that the indexing policy was designed without considering the application’s actual query patterns.

What should the team investigate first?

A. The indexing policy and query execution characteristics

B. Azure Function trigger configuration

C. Event Grid retry settings

D. Container Apps revision traffic

Answer: A

Explanation

Cosmos DB indexing policies have a direct impact on query performance and RU consumption.

Rather than indiscriminately increasing provisioned throughput, developers should first examine query patterns and indexing configuration to determine whether the container is appropriately indexed.

The current AI-200 guide specifically includes optimizing Cosmos DB query performance and RU consumption using indexing policies and consistency levels.

Question 9 — Cosmos DB Change Feed

A document-ingestion application stores uploaded documents in Cosmos DB.

After each document is inserted or updated, a downstream process must:

1. Detect the change.
2. Extract information from the document.
3. Generate an embedding.
4. Store the embedding.

The downstream process should not continuously poll the entire container.

Which Cosmos DB capability is the best fit?

A. Strong consistency

B. Vector similarity search

C. Change feed processor

D. Composite indexing only

Answer: C

Explanation

The Cosmos DB change feed provides a mechanism for detecting changes to items in a container.

A change feed processor can consume those changes and invoke downstream processing without repeatedly scanning the entire container.

This is particularly useful in AI ingestion pipelines where document changes trigger embedding or enrichment operations.

The current AI-200 objectives explicitly include implementing a change feed processor.

Question 10 — Vector Search

A RAG application stores 1 million document chunks in Cosmos DB for NoSQL.

Each chunk contains:

documentId
tenantId
content
embedding

A user query is converted into an embedding.

The application must retrieve semantically similar chunks while restricting results to the user’s tenant.

Which approach is most appropriate?

A. Search the content property using exact string matching.

B. Perform vector similarity search and apply a tenant metadata filter.

C. Use the Cosmos DB change feed to retrieve matching documents.

D. Increase the container’s consistency level to Strong.

Answer: B

Explanation

Vector similarity search provides semantic retrieval based on embeddings.

The tenant filter ensures that candidate documents are restricted to the appropriate security boundary.

Increasing consistency does not implement semantic retrieval, and the change feed is for detecting data changes rather than answering semantic queries.

The AI-200 objectives specifically include storing/retrieving embeddings, vector similarity search, semantic retrieval, and RAG patterns.

Question 11 — PostgreSQL Schema Design

An AI application stores customer information and document embeddings in Azure Database for PostgreSQL.

The application frequently performs:

WHERE tenant_id = ?
  AND document_type = ?

followed by vector similarity search over the resulting records.

Which design consideration is most important?

A. Put all values into a single unstructured text column.

B. Avoid indexes because vector search cannot use metadata.

C. Store metadata in appropriately typed relational columns and design indexes around the query pattern.

D. Store tenant IDs in Azure Key Vault.

Answer: C

Explanation

PostgreSQL provides relational modeling capabilities that should be used appropriately.

Metadata used for filtering should be stored in appropriately typed columns, and indexing strategies should reflect the actual query workload.

Vector search and metadata filtering can then be combined for RAG-style retrieval.

The current AI-200 guide specifically includes schema modeling, data types, indexing strategies, vector similarity search, and metadata filters.

Question 12 — PostgreSQL Vector Workload

A PostgreSQL-based AI application performs vector searches against a large embedding dataset.

Performance analysis shows that vector operations consume substantial CPU.

The development team wants to reduce pgvector compute overhead.

Which area should they investigate?

A. Vector indexing and query strategy

B. Event Grid event filtering

C. Key Vault secret rotation

D. Container Apps revision traffic

Answer: A

Explanation

Vector indexing and query strategy are key factors in the computational cost of pgvector workloads.

An appropriate indexing strategy can reduce the amount of vector computation required for searches.

The AI-200 study guide specifically calls out optimizing query latency and reducing pgvector compute overhead.

Question 13 — PostgreSQL Resource Configuration

A vector-search workload is consistently CPU-bound.

The database contains enough storage, but vector searches are slow under concurrent load.

Which resource should the development team investigate first?

A. Event Grid retry count

B. Container image size

C. PostgreSQL compute and memory resources

D. Azure Key Vault SKU

Answer: C

Explanation

Vector workloads can be computationally intensive. If the workload is CPU-bound, database compute resources should be evaluated.

The AI-200 objectives specifically include configuring compute, memory, and storage resources to support PostgreSQL vector workloads.

Question 14 — Azure Managed Redis

An AI application stores frequently requested retrieval results in Azure Managed Redis.

A cached result should no longer be used after 10 minutes.

Which mechanism should the application use?

A. Cosmos DB change feed

B. Redis key expiration/TTL

C. PostgreSQL vector index

D. Event Grid retry policy

Answer: B

Explanation

Redis supports expiration through TTL semantics.

An application can assign an expiration time to cached data so that stale entries are automatically removed or become unavailable after the specified period.

Caching, expiration, and invalidation are explicitly part of the AI-200 Azure Managed Redis objectives.

Question 15 — Multiple Answers: AI Data Services

A RAG application uses Azure data services.

Which two practices are appropriate?

A. Use vector similarity search for semantic retrieval.

B. Use metadata filtering to restrict candidate records.

C. Treat vector similarity as an authorization mechanism.

D. Store secrets directly in vector metadata.

Answers: A, B

Explanation

Vector similarity is appropriate for semantic retrieval, while metadata filtering can constrain retrieval to relevant records such as a tenant, document type, or access scope.

Vector similarity alone should not be treated as an authorization mechanism. Secrets also shouldn’t be embedded into searchable metadata.

The current AI-200 objectives explicitly include vector similarity search, semantic retrieval, and RAG patterns with metadata filtering.

Section 3 — Connect to and Consume Azure Services

Question 16 — Service Bus Messaging Architecture

An AI application processes financial documents.

Each submitted document must be processed by exactly one available worker. The system may have several worker instances running simultaneously.

If a worker fails while processing a message, the system needs the message to become available for processing again according to Service Bus messaging semantics.

Which messaging pattern is most appropriate?

A. A Service Bus queue with competing consumers

B. An Event Grid topic with three identical subscriptions

C. A Redis cache

D. A Cosmos DB vector index

Answer: A

Explanation

A Service Bus queue can support competing consumers, allowing multiple worker instances to process messages from the same queue.

This differs from a topic with multiple subscriptions, where each subscription receives its own copy of published messages.

Service Bus queues, messages, and dead-letter handling are part of the AI-200 objectives.

Question 17 — Dead-Letter Handling

A Service Bus message has repeatedly failed processing.

The development team does not want the same malformed message to continue consuming normal processing resources.

What should happen to the message?

A. It should be placed in a dead-letter queue according to the configured dead-lettering behavior.

B. It should automatically become a Cosmos DB vector.

C. It should be moved to Azure App Configuration.

D. It should be converted into an Event Grid subscription.

Answer: A

Explanation

Service Bus provides dead-letter queues for messages that cannot be successfully processed or meet configured dead-letter conditions.

Dead-lettering separates problematic messages from normal processing so they can be inspected, repaired, or handled separately.

Dead-letter queue handling is explicitly identified in the AI-200 study guide.

Question 18 — Event Grid vs. Service Bus

An AI system publishes the event:

DocumentAnalysisCompleted

Multiple independent applications need to react to the event.

One application updates analytics, another sends notifications, and another updates a search index.

The publisher should not need to know which applications consume the event.

Which service is the best fit?

A. Azure Service Bus queue

B. Azure Key Vault

C. Azure Event Grid

D. Azure Managed Redis

Answer: C

Explanation

Event Grid is designed for event-driven architectures in which publishers emit events and independent subscribers react to them.

Custom events, filtering, and retries are among the Event Grid capabilities identified in the AI-200 objectives.

Question 19 — Event Grid Filtering

An Event Grid custom topic receives:

DocumentUploaded
DocumentAnalyzed
DocumentRejected

A subscriber should receive only:

DocumentRejected

What should you configure?

A. A Redis TTL

B. An Event Grid event subscription filter

C. A Service Bus dead-letter queue

D. A Cosmos DB indexing policy

Answer: B

Explanation

Event Grid event subscriptions can filter events so that subscribers receive only the events relevant to them.

This prevents every subscriber from having to receive and discard unrelated events.

Filtering is explicitly included in the AI-200 Event Grid objectives.

Question 20 — Azure Functions Binding Design

An HTTP-triggered Azure Function receives a document-processing request.

The function should place a message onto a Service Bus queue without requiring the developer to manually create and manage the Service Bus client in the function’s application logic.

Which capability should the developer consider?

A. A Service Bus output binding

B. An Event Grid retry policy

C. A Cosmos DB vector index

D. An AKS manifest

Answer: A

Explanation

Azure Functions bindings provide declarative integration with external services.

An output binding can allow a function to write to a Service Bus queue without requiring the application code to manually implement all of the messaging client plumbing.

The AI-200 objectives specifically include Functions triggers and bindings.

Question 21 — Functions Trigger Selection

A serverless AI backend must execute whenever a message arrives in a Service Bus queue.

Which trigger should be selected?

A. HTTP trigger

B. Timer trigger

C. Service Bus trigger

D. Cosmos DB output binding

Answer: C

Explanation

A Service Bus trigger causes an Azure Function to execute when the associated Service Bus messaging event occurs.

The distinction is important:

• Trigger → initiates function execution.
• Binding → provides an input/output connection to another service.

Azure Functions triggers and bindings are explicitly part of the AI-200 objectives.

Question 22 — Multiple Answers

An application uses Azure Event Grid for an event-driven workflow.

Which two capabilities can be used to make the workflow more resilient and selective?

A. Event filtering

B. Event delivery retries

C. PostgreSQL pgvector indexes

D. Container Apps revisions

Answers: A, B

Explanation

Event filtering prevents irrelevant events from being delivered to a subscriber.

Retry behavior allows Event Grid to attempt delivery again when a subscriber endpoint temporarily fails.

Both are specifically included in the AI-200 Event Grid objectives.

Question 23 — Fill in the Blank

Complete the statement:

In Azure Functions, a __________ initiates function execution, while a binding provides a declarative connection to input or output data.

Answer: trigger

Explanation

A trigger defines the event that causes a function to execute.

For example, an HTTP trigger can execute a function when an HTTP request arrives, while a Service Bus trigger can execute a function when a message becomes available.

Bindings provide connections to external services and data.

This distinction is fundamental to the Functions portion of AI-200.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Question 24 — Key Vault Security

An application retrieves an API key from Azure Key Vault.

The development team wants the application to access the secret without embedding a permanent credential for Key Vault inside the application source code.

Which approach is most appropriate?

A. Store the Key Vault credential in the container image.

B. Store the credential in the Git repository.

C. Use an appropriate Azure identity-based authentication mechanism and grant the application the required Key Vault permissions.

D. Put the credential in an Event Grid event.

Answer: C

Explanation

The goal is to avoid introducing another hard-coded secret while accessing Key Vault.

An Azure-hosted application can use an appropriate managed identity or other supported identity mechanism, with permissions scoped to the required Key Vault operations.

The AI-200 security objectives include secure secret storage, retrieval, and rotation using Key Vault.

Question 25 — Key Vault vs. App Configuration

A development team identifies the following values:

MaxRetries = 5
EnableNewRAGPipeline = true
ModelDeployment = "production"
DatabasePassword = "..."
ExternalApiKey = "..."

Which design is most appropriate?

A. Store all five values in Key Vault.

B. Store all five values in App Configuration.

C. Store non-sensitive configuration in App Configuration and sensitive values in Key Vault.

D. Store all five values in Redis.

Answer: C

Explanation

App Configuration is designed for application settings and configuration values.

Key Vault is designed for secrets such as passwords and API keys.

The distinction is important because configuration management and secret management serve different purposes.

Microsoft explicitly identifies both Key Vault and App Configuration in the AI-200 security objectives.

Question 26 — Secret Rotation

A security policy requires an AI service API key to be rotated periodically.

The application should always retrieve the current valid value rather than requiring a code deployment whenever the key changes.

Which architecture is most appropriate?

A. Hard-code the key in the application.

B. Store the key in Key Vault and retrieve it at runtime using an appropriate identity.

C. Put the key into an Event Grid event.

D. Bake the key into the Docker image during the build.

Answer: B

Explanation

Key Vault provides secure storage and retrieval of secrets and supports secret lifecycle management.

Separating the secret from the application binary/container image allows the secret to be rotated independently of application deployment.

Secret rotation and retrieval are explicitly listed in the AI-200 objectives.

Question 27 — OpenTelemetry Troubleshooting

A distributed AI application produces the following trace:

HTTP request                  4.8 seconds
 ├── API processing           150 ms
 ├── Cosmos DB query          120 ms
 ├── PostgreSQL query         210 ms
 └── AI inference service     4.1 seconds

Which conclusion is best supported by this telemetry?

A. The container image is too large.

B. Cosmos DB indexing is necessarily incorrect.

C. Service Bus dead-lettering is causing the latency.

D. The AI inference service is the dominant contributor to request latency.

Answer: D

Explanation

The trace shows approximately 4.1 seconds of the 4.8-second request duration being spent in the AI inference service.

Distributed traces are particularly valuable because they expose timing across service boundaries and help isolate latency contributors.

OpenTelemetry distributed tracing is explicitly part of the AI-200 monitoring objectives.

Question 28 — KQL

You are analyzing an application telemetry table called AppRequests.

You need to calculate the average request duration by five-minute interval during the last hour.

Which query is the most appropriate?

A.

AppRequests
| where TimeGenerated > ago(1h)
| summarize avg(DurationMs) by bin(TimeGenerated, 5m)

B.

AppRequests
| top 5 by DurationMs

C.

AppRequests
| project DurationMs

D.

AppRequests
| where DurationMs > 5000

Answer: A

Explanation

The query needs three operations:

1. Restrict the time range to one hour.
2. Group records into five-minute intervals.
3. Calculate the average duration within each interval.

bin(TimeGenerated, 5m) creates the required time buckets, and avg(DurationMs) calculates the average duration.

KQL analysis of logs and metrics is explicitly included in the AI-200 objectives.

Question 29 — Multiple Answers: Telemetry

A distributed AI application is experiencing intermittent latency.

Which two telemetry approaches would provide the most useful information for diagnosing the problem?

A. Distributed traces showing individual request paths

B. Metrics showing aggregate latency/request behavior

C. Container registry repository names

D. Docker image tags

Answers: A, B

Explanation

Distributed traces can show where individual requests spend time across service boundaries.

Metrics provide aggregate information about application behavior, such as latency, request rate, and error rates.

Image tags and registry repository names are useful deployment metadata but aren’t substitutes for runtime telemetry.

OpenTelemetry instrumentation and telemetry analysis are explicitly included in the current AI-200 study guide.

Question 30 — Comprehensive Scenario

A company operates an AI document-processing platform:

                ┌───────────────────────┐
                │   HTTP API            │
                │   Azure Functions     │
                └───────────┬───────────┘
                            │
                            ▼
                    Azure Service Bus
                            │
                            ▼
                Containerized processor
                            │
              ┌─────────────┴─────────────┐
              ▼                           ▼
       Cosmos DB                      PostgreSQL
       documents                     vector search
              │
              ▼
        Embedding data

The application has recently experienced intermittent failures.

The team observes:

• The HTTP API responds quickly.
• Service Bus message counts occasionally increase significantly.
• Container processor CPU usage is low.
• PostgreSQL latency remains normal.
• Distributed traces show that some messages wait several minutes before processing begins.
• The application currently scales the processor based primarily on CPU utilization.

What should the team implement to address the primary bottleneck?

A. Increase PostgreSQL compute.

B. Increase Cosmos DB consistency.

C. Implement event-driven scaling for the container processor based on the messaging workload.

D. Increase OpenTelemetry sampling.

Answer: C

Explanation

The most important clues are:

• Service Bus backlog increases.
• CPU remains low.
• Messages wait before processing.
• The current scaling strategy is CPU-oriented.

The processor therefore isn’t scaling in response to the actual workload.

For a containerized application running in Azure Container Apps, KEDA-based event-driven scaling can scale replicas according to an external event source or workload metric.

Increasing PostgreSQL resources would not address the observed queue backlog because PostgreSQL latency is normal.

OpenTelemetry has already provided useful diagnostic information, but increasing sampling would not resolve the scaling problem.

This question combines the AI-200 containerization, messaging, monitoring, and troubleshooting objectives and represents the type of cross-topic reasoning expected from an experienced Azure developer.

Go to the AI-200 Exam Prep Hub main page

This post is a part of the AI-200: Developing AI Cloud Solutions on Azure  Exam Prep Hub.

Section 1 — Develop Containerized Solutions on Azure

Questions 1–7

Question 1 — Scenario-Based: Azure Container Apps

A company has developed an AI inference service as a container image.

The application has the following requirements:

• It must run continuously while requests are being processed.
• It should scale horizontally when request volume increases.
• The team does not want to manage Kubernetes control planes or nodes.
• The application will eventually have multiple versions running during controlled releases.
• The team wants to use container images stored in Azure Container Registry.

Which Azure service is the best hosting platform?

A. Azure Kubernetes Service
B. Azure Functions
C. Azure Container Apps
D. Azure Storage static website

Answer: C

Explanation

Azure Container Apps is designed for running containerized applications without requiring the development team to manage Kubernetes infrastructure directly. It supports container images, scaling, revisions, and environment configuration.

AKS would provide considerably more Kubernetes control, but it also introduces additional management responsibilities. Azure Functions is appropriate for serverless functions rather than a continuously running containerized service of this type.

The AI-200 objectives specifically include deploying containers to Container Apps, configuring environments, managing revisions, and implementing event-driven scaling with KEDA.

Question 2 — Azure Container Registry Tasks

A development team has a Dockerfile stored in a Git repository.

Whenever changes are committed to the repository, the team wants Azure to automatically build a new container image and push it to Azure Container Registry.

The team does not want to maintain a dedicated build server.

Which solution should you implement?

A. Configure an Azure Container Registry Task with a source-code trigger
B. Create an AKS CronJob that executes Docker
C. Configure an App Service deployment slot
D. Create an Azure Function with a timer trigger that builds the image

Answer: A

Explanation

Azure Container Registry Tasks can automate container image builds in Azure. They can be triggered by source-code changes and can build and push images to ACR.

The important distinction is that ACR Tasks are specifically designed for container image build automation. App Service slots and Azure Functions don’t provide the same purpose-built container build capability.

ACR Tasks are explicitly part of the AI-200 containerization objectives.

Question 3 — AKS Deployment Troubleshooting

You deploy an AI API to AKS using a Kubernetes deployment manifest.

The deployment reports that the pods have been created, but the application is inaccessible from outside the cluster.

You verify that:

• The container image can be pulled.
• The pods are running.
• The application process is listening on the expected container port.

What should you investigate next?

A. The Azure Container Registry retention policy
B. The PostgreSQL connection pool
C. The Cosmos DB indexing policy
D. The Kubernetes Service and ingress/network configuration

Answer: D

Explanation

If the pods are running and the application is listening correctly, the next logical area is connectivity between the pods and external clients.

In AKS, this can involve the Kubernetes Service, ingress configuration, ports, selectors, networking, and related resources.

The AI-200 study guide specifically calls out monitoring and troubleshooting AKS and Container Apps by inspecting logs, events, and end-to-end connectivity.

Question 4 — Multiple Answers

An application is deployed to Azure Container Apps.

The application has two revisions:

• Revision A — currently serving production traffic
• Revision B — newly deployed version

The development team wants to validate Revision B before directing production traffic to it.

Which two capabilities are relevant?

A. Azure Container Registry Tasks
B. Container Apps revision management
C. Revision traffic management
D. Cosmos DB change feed

Answers: B, C

Explanation

Azure Container Apps supports revisions, allowing different versions of an application to coexist. Traffic can be managed between revisions, supporting controlled deployments and testing.

ACR Tasks handles container image builds and is not responsible for Container Apps traffic management.

Microsoft explicitly includes revision management in the AI-200 Container Apps objectives.

Question 5 — Container Apps Scaling

An AI application receives requests through an event-driven architecture.

Under normal conditions, there may be only a few messages waiting to be processed. During business events, thousands of messages may accumulate.

The application should automatically create additional container replicas when the message workload increases.

Which capability is most appropriate?

A. App Service deployment slots
B. ACR geo-replication
C. KEDA-based event-driven scaling
D. AKS node autoscaling only

Answer: C

Explanation

KEDA—Kubernetes Event-driven Autoscaling—allows Container Apps to scale based on external event sources and metrics.

This differs from simply scaling based on CPU or memory. A queue-length or other event-based workload is a classic use case for event-driven scaling.

The AI-200 study guide specifically identifies KEDA as the mechanism for event-driven scaling in Container Apps.

Question 6 — Multiple Answers

You are diagnosing a failing AKS deployment.

Which two sources should you inspect to help determine why the application is not behaving as expected?

A. Kubernetes/application logs
B. Kubernetes events
C. Azure App Configuration feature flags only
D. PostgreSQL vector indexes

Answers: A, B

Explanation

Application and container logs can reveal runtime failures, exceptions, and startup problems. Kubernetes events can reveal scheduling problems, image-pull failures, probe failures, container restarts, and other cluster-level conditions.

The AI-200 objectives explicitly include inspecting logs and events when troubleshooting AKS and Container Apps.

Question 7 — App Service Container Configuration

A containerized AI API runs on Azure App Service.

The application requires a configuration value named AI_ENDPOINT and a sensitive value named API_KEY.

The development team wants these values supplied to the container as environment variables rather than hard-coded into the image.

Which approach is most appropriate?

A. Configure App Service application settings/environment variables and use a secure secret-management approach for the sensitive value
B. Add both values directly to the Dockerfile
C. Store both values in the container image metadata
D. Put both values in the ACR repository name

Answer: A

Explanation

App Service can supply application configuration to a container through application settings/environment variables. Sensitive values should not be baked into the container image.

The AI-200 study guide specifically includes configuring App Service to supply environment variables and secrets.

Section 2 — Develop AI Solutions Using Azure Data Management Services

Questions 8–15

Question 8 — Cosmos DB Consistency and RU Consumption

An AI application uses Azure Cosmos DB for NoSQL.

The application does not require every read to immediately reflect the latest write. However, it performs a very large number of reads, and the development team wants to optimize the workload’s consistency/performance tradeoff.

Which Cosmos DB configuration area should they investigate?

A. Container Apps revision settings
B. Consistency level
C. Azure Functions trigger type
D. Event Grid retry policy

Answer: B

Explanation

Cosmos DB consistency levels determine the guarantees provided when reading data. Stronger consistency generally involves different performance and availability tradeoffs than weaker consistency levels.

The AI-200 study guide explicitly includes optimizing Cosmos DB query performance and RU consumption by using indexing policies and consistency levels.

Question 9 — Cosmos DB Query Optimization

A Cosmos DB query frequently filters documents using a property called departmentId.

The query is expensive and consumes more RUs than expected.

The development team discovers that the property is excluded from the container’s indexing policy.

What should they consider doing?

A. Increase the Service Bus lock duration
B. Create a KEDA scaler
C. Move the documents to Azure Managed Redis
D. Modify the indexing policy to appropriately index the property

Answer: D

Explanation

Cosmos DB indexing policies determine which paths are indexed and therefore influence query execution and RU consumption.

If a frequently filtered property isn’t appropriately indexed, changing the indexing policy may improve query performance and reduce unnecessary RU consumption.

Indexing policies are explicitly part of the AI-200 Cosmos DB objectives.

Question 10 — Cosmos DB Vector Search

An AI application stores the following document:

{
    "id": "doc-1024",
    "tenantId": "contoso",
    "text": "Azure provides cloud-based AI services...",
    "embedding": [ ... ]
}

The application receives a query embedding and needs to retrieve semantically similar documents.

Which capability should be implemented?

A. Cosmos DB vector similarity search
B. Cosmos DB change feed only
C. Azure Functions timer trigger
D. Service Bus topic filtering

Answer: A

Explanation

The embedding represents the semantic characteristics of the document. Vector similarity search compares the query embedding with stored embeddings to identify semantically similar content.

This is a core AI workload supported by Cosmos DB for NoSQL and is explicitly included in the AI-200 objectives.

Question 11 — Scenario-Based RAG

A RAG application stores documents for multiple customers in Azure Database for PostgreSQL.

Each vector record includes:

• tenant_id
• document_type
• content
• embedding

A user from tenant A asks a question.

The application must ensure that results from tenant B are never returned, even if tenant B contains documents that are more semantically similar.

Which approach should be used?

A. Increase vector dimensions
B. Perform vector similarity search with a metadata filter for tenant_id
C. Use Event Grid to filter documents
D. Store tenant IDs in Azure Key Vault

Answer: B

Explanation

The vector search provides semantic similarity, while the metadata filter constrains the candidate records to the correct tenant.

This is especially important in multi-tenant RAG architectures. Semantic similarity alone should not be treated as an authorization boundary.

The AI-200 study guide specifically includes RAG patterns using vector search with metadata filters.

Question 12 — PostgreSQL Performance

An application performs thousands of short database operations against Azure Database for PostgreSQL.

Performance testing shows that establishing a new database connection for every request introduces significant latency.

Which optimization should be considered?

A. Increase the number of Event Grid subscriptions
B. Use connection pooling or otherwise optimize connection reuse
C. Replace PostgreSQL with ACR
D. Store all database credentials in source code

Answer: B

Explanation

Creating and tearing down database connections repeatedly introduces overhead. Connection pooling allows connections to be reused across operations, improving throughput and reducing connection-establishment latency.

Connection optimization is explicitly listed in the current AI-200 study guide.

Question 13 — Azure Managed Redis

An AI application repeatedly retrieves the same expensive results from a backend data service.

The results can safely remain cached for five minutes.

After five minutes, the application should retrieve fresh data.

Which Azure Managed Redis capability is most directly applicable?

A. Change feed processing
B. PostgreSQL vector indexing
C. Service Bus dead-lettering
D. Key expiration/TTL

Answer: D

Explanation

Redis supports expiration/TTL semantics, allowing cached data to automatically expire after a specified period.

This is useful when data should remain cached temporarily but must eventually be refreshed.

The AI-200 objectives specifically include caching, expiration, and invalidation using Azure Managed Redis.

Question 14 — Multiple Answers

An AI application uses Azure Managed Redis.

Which two capabilities are directly relevant to AI workloads covered by AI-200?

A. Vector indexing for similarity search
B. Caching frequently accessed data
C. Kubernetes manifest deployment
D. Azure Function trigger execution

Answers: A, B

Explanation

Azure Managed Redis can be used for low-latency caching and supports vector storage/indexing capabilities for AI scenarios.

Kubernetes manifests belong to AKS, while Function triggers belong to Azure Functions.

The current AI-200 study guide specifically identifies Redis caching, expiration/invalidation, and vector indexing.

Question 15 — Matching: AI Data Services

Match each requirement to the best Azure technology.

Answers

• 1 → B
• 2 → C
• 3 → A
• 4 → D

Explanation

The Cosmos DB change feed is designed to detect item changes. PostgreSQL can use pgvector for vector workloads. Managed Redis provides low-latency caching and expiration as well as vector capabilities.

These capabilities map directly to the data-management objectives in the current AI-200 guide.

Section 3 — Connect to and Consume Azure Services

Questions 16–23

Question 16 — Service Bus vs. Event Grid

An AI application needs reliable asynchronous processing of individual work items.

Each work item represents a document that must be processed exactly as part of an application workflow. If processing fails, the message must remain available for retry or dead-letter handling.

Which service is the better fit?

A. Event Grid
B. Azure App Configuration
C. Azure Managed Redis
D. Azure Service Bus

Answer: D

Explanation

Azure Service Bus is designed for enterprise messaging and reliable asynchronous processing. It supports queues, topics, subscriptions, message handling, and dead-letter queues.

Event Grid is primarily an event-routing service for reactive architectures. When the requirement centers on reliable message processing and dead-letter handling, Service Bus is generally the better fit.

These capabilities are explicitly included in the AI-200 messaging objectives.

Question 17 — Service Bus Topic Architecture

An AI document-processing application publishes a single event whenever a document is processed.

Three independent applications need to react to the event:

1. Billing
2. Analytics
3. Notification

Each application must independently receive the events.

Which Service Bus architecture should you use?

A. A topic with separate subscriptions
B. A single queue consumed by all applications
C. A Redis key with a five-minute expiration
D. A Function timer trigger

Answer: A

Explanation

A Service Bus topic allows a publisher to send messages once while multiple subscriptions independently receive messages.

This is appropriate when several consumers need their own copy/stream of messages.

Queues are more appropriate when competing consumers share work rather than when independent applications each need to receive the published message.

Topics and subscriptions are explicitly part of the AI-200 objectives.

Question 18 — Event Grid Filtering

A custom Event Grid topic receives events from several types of AI processing operations.

A downstream service should receive only events where:

eventType = "DocumentAnalysisCompleted"

What should you configure?

A. A Service Bus dead-letter queue
B. An App Service deployment slot
C. An Event Grid event subscription with filtering
D. A Cosmos DB indexing policy

Answer: C

Explanation

Event Grid subscriptions can use event filtering to restrict which events are delivered to a subscriber.

This allows a publisher to emit multiple event types while individual consumers receive only events relevant to them.

Event Grid filters, custom events, and retry behavior are explicitly listed in the AI-200 objectives.

Question 19 — Event Grid Retry Behavior

An Event Grid subscriber’s endpoint is temporarily unavailable.

The application should allow Event Grid to attempt delivery again rather than permanently losing the event immediately.

Which Event Grid capability should you configure?

A. Vector indexing
B. Event delivery retry policy
C. Container Apps revision
D. Cosmos DB consistency level

Answer: B

Explanation

Event Grid provides retry capabilities for event delivery. Retry configuration allows applications to tolerate temporary endpoint failures.

Retry behavior is distinct from Service Bus dead-lettering. Service Bus is designed around reliable messaging and message processing, while Event Grid provides event routing with retry and delivery semantics.

The AI-200 study guide explicitly identifies Event Grid retries as an exam objective.

Question 20 — Azure Functions Architecture

An AI backend must expose an HTTP endpoint:

POST /documents

The endpoint accepts a document and places a processing request onto a Service Bus queue.

The backend should be serverless.

Which Azure Functions design is most appropriate?

A. Timer-triggered function that polls the HTTP endpoint
B. Event Grid-triggered function with a Redis output
C. Cosmos DB change-feed function
D. HTTP-triggered function with a Service Bus output binding

Answer: D

Explanation

An HTTP trigger can expose the API endpoint. A Service Bus output binding can then send the processing message to a queue.

This design avoids unnecessary polling and allows the HTTP-facing function to remain lightweight while the actual document processing happens asynchronously.

The AI-200 objectives include serverless APIs, triggers, bindings, and function-app deployment.

Question 21 — Azure Functions Trigger vs. Binding

A developer creates an Azure Function that should execute whenever a new message arrives in a Service Bus queue.

Which component determines when the function executes?

A. Trigger
B. Output binding
C. Application setting
D. Deployment slot

Answer: A

Explanation

The trigger defines the event that causes the function to execute.

A binding provides a declarative connection between the function and another service or data source. The trigger is therefore the component responsible for initiating execution.

Triggers and bindings are explicitly included in the AI-200 Functions objectives.

Question 22 — Multiple Answers

A development team is choosing between Azure Service Bus and Event Grid for an AI backend.

Which two statements are correct?

A. Service Bus is appropriate for reliable message-based processing.
B. Event Grid is designed for event-driven routing and supports event filtering.
C. Event Grid replaces Azure Key Vault for secret storage.
D. Service Bus is primarily a container image registry.

Answers: A, B

Explanation

Service Bus provides messaging capabilities such as queues, topics, subscriptions, and dead-letter queues.

Event Grid provides event routing and supports capabilities such as custom events, filtering, and retries.

Neither service is a secret-management or container-registry service.

Question 23 — Fill in the Blank

Complete the statement:

In Azure Functions, a __________ defines the event or condition that causes a function to execute, while a binding provides a connection to input or output data.

Answer: trigger

Explanation

A Function trigger determines when the function executes. Bindings simplify access to external resources and can provide input or output data.

Understanding this distinction is fundamental to designing serverless AI backends with Azure Functions.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Questions 24–30

Question 24 — Key Vault Secret Rotation

An AI application uses an API key stored in Azure Key Vault.

The security team requires the secret to be rotated periodically without requiring developers to modify application source code.

Which approach best addresses the requirement?

A. Implement secret rotation and have the application retrieve the current secret from Key Vault
B. Store a second copy of the secret in the Dockerfile
C. Put the secret in an Event Grid event
D. Store the secret as a PostgreSQL vector

Answer: A

Explanation

Key Vault is designed to securely store secrets and supports secret lifecycle management. Applications can retrieve the current value rather than embedding secrets in source code or container images.

The current AI-200 study guide specifically includes secret rotation and retrieval using Azure Key Vault.

Question 25 — Key Vault vs. App Configuration

An application has the following configuration:

• MaxDocumentsPerRequest = 25
• EnableSemanticSearch = true
• DatabaseConnectionPassword = [secret]
• AIServiceApiKey = [secret]

Which approach is most appropriate?

A. Store everything in Azure Container Registry
B. Store everything in Azure App Configuration
C. Store non-secret configuration in App Configuration and secrets in Key Vault
D. Store everything in Service Bus

Answer: C

Explanation

Azure App Configuration is designed for centralized application settings and configuration.

Azure Key Vault is designed for sensitive values such as passwords and API keys.

Separating ordinary configuration from secrets provides a more appropriate security and configuration-management architecture.

Both services are explicitly included in the AI-200 security objectives.

Question 26 — OpenTelemetry

A distributed AI application has this request path:

Client
   ↓
API
   ↓
Document service
   ↓
PostgreSQL
   ↓
AI inference service

Users report that some requests take 8–10 seconds.

The development team needs to determine which component contributes most of the latency for each individual request.

Which capability is most appropriate?

A. OpenTelemetry distributed tracing
B. ACR image replication
C. Cosmos DB change feed
D. Service Bus topic filtering

Answer: A

Explanation

Distributed tracing allows developers to follow a request through multiple services and identify where time is being spent.

OpenTelemetry provides standardized instrumentation for collecting telemetry across distributed applications.

The AI-200 study guide specifically identifies tracing distributed systems using OpenTelemetry SDKs.

Question 27 — KQL

You have an Azure Monitor Logs table called AppRequests.

You need to find the 10 slowest requests from the previous hour.

Which query is the best starting point?

A.

AppRequests
| summarize count()

B.

AppRequests
| where TimeGenerated > ago(1h)
| summarize avg(DurationMs)

C.

AppRequests
| project DurationMs

D.

AppRequests
| where TimeGenerated > ago(1h)
| top 10 by DurationMs desc

Answer: D

Explanation

The query needs to:

1. Restrict records to the previous hour.
2. Sort/select the highest-duration requests.
3. Return only the top 10.

top 10 by DurationMs desc directly satisfies the requirement.

KQL is explicitly part of the AI-200 monitoring objectives for analyzing logs and metrics.

Question 28 — Multiple Answers

You instrument an AI application with OpenTelemetry.

Which two types of telemetry are particularly useful when diagnosing performance problems in a distributed application?

A. Container image tags
B. Traces
C. Metrics
D. ACR repository names

Answers: B, C

Explanation

Traces can show the path and timing of individual requests across distributed services.

Metrics can reveal aggregate measurements such as latency, request rates, error rates, or resource-related behavior.

Container image tags and ACR repository names are deployment metadata rather than the primary telemetry types used for distributed performance analysis.

OpenTelemetry and telemetry analysis are explicitly included in the AI-200 monitoring objectives.

Question 29 — KQL Scenario

An AI application has started returning HTTP 500 errors.

You want to determine whether the errors increased significantly during the last 30 minutes.

Which KQL query is the most useful starting point?

A.

AppRequests
| where TimeGenerated > ago(30m)
| summarize count() by bin(TimeGenerated, 5m), ResultCode

B.

AppRequests
| project TimeGenerated

C.

AppRequests
| summarize avg(DurationMs)

D.

AppRequests
| top 1 by TimeGenerated

Answer: A

Explanation

The query:

• restricts data to the last 30 minutes,
• groups data into five-minute intervals,
• separates results by HTTP result code,
• and counts the requests.

This allows the development team to observe whether HTTP 500 responses increased during particular time intervals.

The ability to write KQL queries to analyze logs and metrics is part of the current AI-200 study guide.

Question 30 — Scenario-Based Troubleshooting

An AI API is running in Azure Container Apps.

The application works correctly under light load. Under heavy load, however:

• request latency increases significantly,
• CPU usage remains relatively low,
• the application receives work from a messaging system,
• and the number of pending messages increases continuously.

The development team wants the application to automatically add replicas based on the workload rather than CPU utilization.

What should you implement?

A. KEDA event-driven scaling based on the messaging workload
B. A larger Azure Container Registry SKU
C. A stronger Cosmos DB consistency level
D. OpenTelemetry sampling alone

Answer: A

Explanation

The critical clue is that the workload is message-driven and the backlog is increasing while CPU utilization remains low.

CPU-based autoscaling would not necessarily respond appropriately. KEDA allows Container Apps to scale based on event-driven workload characteristics, such as the number of pending messages.

OpenTelemetry could help diagnose the latency, but instrumentation alone would not automatically add replicas.

KEDA-based event-driven scaling is explicitly identified in the AI-200 containerized-solutions objectives.

Go to the AI-200 Exam Prep Hub main page

This post/practice exam is a part of the AI-200: Developing AI Cloud Solutions on Azure  Exam Prep Hub.

Section 1 — Develop Containerized Solutions on Azure

Questions 1–7

Question 1 — Single Answer

You are developing an AI-powered document-processing application. The application is packaged as a Docker image and must be deployed to Azure App Service.

The development team wants App Service to retrieve the image from Azure Container Registry (ACR).

Which configuration is required?

A. Configure the App Service container settings to use the ACR image and provide the required registry authentication
B. Create an Azure Service Bus subscription between ACR and App Service
C. Configure an Event Grid subscription that automatically converts the image into an App Service package
D. Store the Docker image in Azure Blob Storage and configure App Service to mount the blob

Answer: A

Explanation: Azure App Service can run containerized applications using images stored in a container registry such as ACR. The App Service must be configured with the appropriate container image and registry authentication. A Service Bus subscription or Event Grid subscription is not required simply to deploy the image.

Question 2 — Single Answer

A development team wants to automatically build a container image whenever source code is committed. They want the container image to be built directly within Azure without maintaining a dedicated build server.

Which Azure Container Registry capability should you use?

A. ACR replication
B. Azure Container Registry Tasks
C. Azure Container Apps revisions
D. AKS Jobs

Answer: B

Explanation: Azure Container Registry Tasks can automate container image builds and related tasks. They can build images in Azure and can be integrated with source-control or registry workflows. This eliminates the need to maintain a dedicated build environment for the image-building process.

Question 3 — Scenario-Based, Single Answer

A company deploys an AI inference API to Azure Container Apps.

The application receives normal traffic throughout the day, but occasionally receives bursts of messages from an Azure messaging system. The company wants the number of application instances to automatically increase based on the number of pending messages.

Which capability should you use?

A. Container Apps revision traffic splitting
B. Azure App Service autoscale rules based on CPU
C. Kubernetes Event-driven Autoscaling (KEDA)
D. Azure Container Registry Tasks

Answer: C

Explanation: Azure Container Apps supports event-driven scaling through KEDA. KEDA allows scaling decisions to be based on external event sources, such as message queues, rather than relying solely on CPU or memory utilization.

Question 4 — Multiple Answers

You are troubleshooting an application running in Azure Container Apps.

Which two actions can help diagnose application problems?

A. Inspect application logs
B. Inspect container/application events
C. Change the Cosmos DB consistency level
D. Create a Service Bus topic

Answers: A, B

Explanation: Container Apps troubleshooting can involve examining logs and events associated with the application and its containers. Changing Cosmos DB consistency or creating a Service Bus topic does not directly diagnose a Container Apps deployment problem.

Question 5 — Matching

Match each Azure container technology or feature with the most appropriate description.

Answer:

• 1 → B
• 2 → A
• 3 → C
• 4 → D

Explanation: ACR provides container image storage and management; Container Apps provides managed application hosting for containers; AKS provides managed Kubernetes; and KEDA provides event-driven autoscaling capabilities used by Container Apps.

Question 6 — Single Answer

You have deployed an application to AKS using a Kubernetes manifest.

The application starts successfully, but users cannot reach it through the expected endpoint.

Which approach should you take first to investigate the problem?

A. Rebuild the container image using ACR Tasks
B. Increase the Cosmos DB RU/s limit
C. Inspect Kubernetes resources, events, logs, and connectivity configuration
D. Create an Event Grid custom topic

Answer: C

Explanation: Microsoft specifically identifies monitoring and troubleshooting AKS applications through logs, events, and end-to-end connectivity as part of the AI-200 skill set. A deployment can succeed while networking, service, ingress, or application configuration prevents clients from reaching the application.

Question 7 — Single Answer

A new version of a containerized AI API is deployed to Azure Container Apps. The team wants to test the new version without immediately sending all production traffic to it.

Which Container Apps capability is most appropriate?

A. Container Apps revisions
B. ACR Tasks
C. Kubernetes DaemonSets
D. Azure Functions bindings

Answer: A

Explanation: Azure Container Apps supports revisions, allowing different versions of an application to be deployed and managed independently. Traffic can then be managed between revisions, supporting controlled rollout scenarios.

Section 2 — Develop AI Solutions Using Azure Data Management Services

Questions 8–15

Question 8 — Single Answer

An AI application uses Azure Cosmos DB for NoSQL to store documents and their embeddings.

The application needs to retrieve documents whose embeddings are semantically similar to a query embedding.

Which capability should the application use?

A. Change feed
B. Vector similarity search
C. Azure Functions timer trigger
D. Event Grid retry policy

Answer: B

Explanation: Azure Cosmos DB for NoSQL supports storing embeddings and performing vector similarity search. This capability is useful for semantic retrieval and AI/RAG scenarios.

Question 9 — Scenario-Based, Single Answer

An application frequently queries a Cosmos DB for NoSQL container using a property called category.

The query workload has grown significantly, and the development team wants to reduce unnecessary RU consumption by ensuring frequently queried properties are indexed appropriately.

What should the team investigate?

A. Cosmos DB indexing policy
B. Azure Service Bus lock duration
C. Container Apps revision settings
D. Azure Key Vault rotation policy

Answer: A

Explanation: Cosmos DB indexing policies affect how queries are executed and can influence RU consumption and query performance. Designing an appropriate indexing policy is an important part of optimizing Cosmos DB workloads.

Question 10 — Multiple Answers

An AI application uses Azure Cosmos DB for NoSQL.

Which two capabilities are directly relevant to implementing AI retrieval workflows?

A. Storing embeddings
B. Performing vector similarity searches
C. Creating App Service deployment slots
D. Configuring Service Bus dead-letter queues

Answers: A, B

Explanation: Cosmos DB for NoSQL can store embeddings and perform vector similarity searches. These capabilities support semantic retrieval and RAG-style AI applications.

Question 11 — Single Answer

A document-processing application needs to react whenever new or updated items are written to an Azure Cosmos DB for NoSQL container.

Which Cosmos DB capability is designed for this purpose?

A. Analytical store
B. Change feed
C. Vector index
D. Consistency policy

Answer: B

Explanation: The Cosmos DB change feed provides an ordered record of changes to items in a container and can be used to detect and process new or updated items. The AI-200 study guide explicitly includes implementing a change feed processor.

Question 12 — Fill in the Blank

Complete the statement:

Azure Database for PostgreSQL can support vector similarity search for AI workloads by using the __________ extension.

Answer: pgvector

Explanation: PostgreSQL AI workloads can use the pgvector extension to store and search vector embeddings. Microsoft specifically identifies Azure Database for PostgreSQL with pgvector as an AI data service covered by the course and exam.

Question 13 — Scenario-Based, Single Answer

A company is implementing a RAG application using Azure Database for PostgreSQL.

Each document chunk contains:

• an embedding
• document text
• a tenant ID
• a document type

The application must retrieve semantically similar chunks but only from the current tenant.

What should the application implement?

A. Vector similarity search combined with metadata filtering
B. A Service Bus subscription filtered by tenant ID
C. An Azure Function timer trigger
D. A Redis expiration policy

Answer: A

Explanation: Vector similarity search retrieves semantically related records, while metadata filtering restricts the result set to relevant records such as a particular tenant. The AI-200 study guide specifically calls out semantic retrieval and RAG patterns using metadata filters with PostgreSQL.

Question 14 — Single Answer

An AI application performs expensive vector searches against Azure Database for PostgreSQL.

The team wants to reduce vector-search latency and unnecessary computational overhead.

Which area should they investigate?

A. Azure Event Grid retry policies
B. pgvector indexing and query optimization
C. App Configuration feature flags
D. Service Bus dead-letter queues

Answer: B

Explanation: PostgreSQL vector workloads can be optimized through appropriate indexing strategies and pgvector configuration. Microsoft specifically includes optimizing vector search and reducing pgvector compute overhead in the AI-200 objectives.

Question 15 — Matching

Match each Azure data technology with the most appropriate use case.

Answer:

• 1 → A
• 2 → B
• 3 → C
• 4 → D

Explanation: These are distinct but complementary AI data patterns. Cosmos DB supports NoSQL document workloads and vector search; PostgreSQL supports relational workloads and pgvector; Azure Managed Redis supports caching and vector capabilities; and Cosmos DB change feed supports processing item changes.

Section 3 — Connect to and Consume Azure Services

Questions 16–23

Question 16 — Single Answer

An AI application submits long-running document-processing requests.

The API should return quickly rather than waiting for processing to finish. A backend worker should process the requests asynchronously.

Which Azure service is most appropriate for queuing the work?

A. Azure Key Vault
B. Azure Service Bus
C. Azure App Configuration
D. Azure Container Registry

Answer: B

Explanation: Azure Service Bus provides messaging capabilities appropriate for decoupling producers from consumers and processing backend operations asynchronously. The AI-200 objectives specifically include queuing and processing backend operations using Service Bus.

Question 17 — Scenario-Based, Single Answer

An AI application uses Azure Service Bus.

Messages that repeatedly fail processing should be isolated so that they do not continue to interfere with normal message processing.

What should the application use?

A. A dead-letter queue
B. An Event Grid custom topic
C. An App Configuration key
D. A Cosmos DB change feed

Answer: A

Explanation: Azure Service Bus provides dead-letter queues for messages that cannot be successfully processed or that meet specified dead-lettering conditions. This allows problematic messages to be isolated for inspection or later processing.

Question 18 — Multiple Answers

You are designing an AI workflow using Azure Service Bus.

Which two capabilities are directly supported by Service Bus and relevant to the AI-200 objectives?

A. Topics and subscriptions
B. Dead-letter queues
C. Vector similarity search
D. Container image versioning

Answers: A, B

Explanation: The AI-200 study guide explicitly includes Service Bus messages, topics, subscriptions, and dead-letter queue handling. Vector search and container image versioning are handled by other Azure services.

Question 19 — Single Answer

A company wants an application to react whenever a new image is added to an Azure Storage account.

The workflow should be event-driven rather than continuously polling the storage account.

Which Azure service should be used to route the event?

A. Azure Event Grid
B. Azure Key Vault
C. Azure Managed Redis
D. Azure Container Registry Tasks

Answer: A

Explanation: Event Grid is designed for event-driven architectures. It can route events from Azure resources to handlers and supports event filtering and retry behavior.

Question 20 — Scenario-Based, Single Answer

An AI application needs a lightweight HTTP API that performs a small amount of processing and then returns a response.

The API does not require a continuously running server.

Which Azure service is most appropriate?

A. Azure Kubernetes Service
B. Azure Functions
C. Azure Container Registry
D. Azure Service Bus

Answer: B

Explanation: Azure Functions provides serverless execution and supports HTTP-triggered functions that can implement APIs without requiring developers to manage a continuously running server infrastructure. The AI-200 objectives include building serverless APIs using triggers and bindings.

Question 21 — Single Answer

You are developing an Azure Function that should execute whenever a message arrives in a supported messaging system.

Which Azure Functions capability determines what causes the function to execute?

A. Binding
B. Trigger
C. Revision
D. Indexing policy

Answer: B

Explanation: A Function trigger defines the event that causes a function to execute. Bindings provide a declarative way to connect a function to input and output data or services.

Question 22 — Multiple Answers

Which two statements correctly describe Azure Functions concepts?

A. A trigger determines when a function executes.
B. Bindings can simplify interaction with external data or services.
C. A trigger is primarily used to create a PostgreSQL vector index.
D. Bindings replace all Azure authentication mechanisms.

Answers: A, B

Explanation: Triggers define function execution events, while bindings provide connections to data and services. They do not create database indexes or eliminate the need for authentication and authorization.

Question 23 — Scenario-Based, Single Answer

An organization publishes custom business events for its AI workflow. Several downstream applications should independently receive the events.

The organization also needs to apply event filters so that each subscriber receives only the events relevant to it.

Which Azure service is the best fit?

A. Azure Service Bus queue
B. Azure Event Grid
C. Azure Key Vault
D. Azure App Service

Answer: B

Explanation: Event Grid is designed for event-driven architectures and supports custom events and event filtering. It is appropriate when publishers emit events and multiple subscribers independently react to those events.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Questions 24–30

Question 24 — Single Answer

An AI application requires an API key to access an external AI service.

The development team currently stores the key directly in the application’s source code.

What is the best Azure-native solution?

A. Store the key in Azure Container Registry
B. Store the key in Azure App Configuration as plain text
C. Store the key in Azure Key Vault
D. Store the key in an Azure Service Bus message

Answer: C

Explanation: Azure Key Vault is designed to securely store and retrieve secrets such as API keys, passwords, and other sensitive configuration information. Hard-coding secrets in source code should be avoided.

Question 25 — Scenario-Based, Single Answer

A company wants to change application configuration values without rebuilding and redeploying the application.

The configuration includes feature flags and non-secret application settings.

Which service should be used?

A. Azure App Configuration
B. Azure Key Vault
C. Azure Container Registry
D. Azure Service Bus

Answer: A

Explanation: Azure App Configuration provides centralized management of application settings and configuration. Key Vault is primarily intended for secrets and other sensitive values.

Question 26 — Multiple Answers

A company is designing secure configuration management for an AI application.

Which two approaches are appropriate?

A. Store sensitive secrets in Azure Key Vault.
B. Store application configuration information in Azure App Configuration.
C. Store API secrets directly in application source code.
D. Put database passwords into Event Grid event payloads.

Answers: A, B

Explanation: Key Vault is designed for secrets, while App Configuration provides centralized application configuration management. Secrets should not be embedded in source code or unnecessarily exposed in event payloads.

Question 27 — Single Answer

An AI application consists of multiple distributed services.

A request enters an API, invokes a backend service, calls a database, and then invokes another service.

The development team needs to follow the request across these components to identify where latency is occurring.

Which technology should they use?

A. Azure Container Registry Tasks
B. OpenTelemetry
C. Cosmos DB indexing
D. Service Bus dead-lettering

Answer: B

Explanation: OpenTelemetry provides standardized application instrumentation for collecting telemetry such as traces, metrics, and related diagnostic information. Distributed tracing can help follow a request across multiple services.

Question 28 — Scenario-Based, Single Answer

You need to analyze application logs stored in Azure Monitor Logs.

You want to find all requests where the duration was greater than 2 seconds and return the most recent results first.

Which technology should you use?

A. Dockerfile
B. KQL
C. pgvector
D. KEDA

Answer: B

Explanation: Kusto Query Language (KQL) is used to query and analyze data in Azure Monitor Logs and other Azure data platforms. The AI-200 study guide explicitly includes writing KQL queries to analyze logs and metrics.

Question 29 — Matching

Match each technology with its primary purpose.

Answer:

• 1 → B
• 2 → A
• 3 → C
• 4 → D

Explanation: Key Vault handles secrets, App Configuration manages application settings, OpenTelemetry provides instrumentation and telemetry, and KQL is used to query and analyze telemetry and log data.

Question 30 — Scenario-Based, Single Answer

An AI application is experiencing intermittent performance problems.

The application consists of several microservices running in Azure. Users report that some requests take several seconds to complete, but CPU utilization on the individual services does not consistently appear high.

The development team wants to determine which downstream service is contributing to the latency for individual requests.

Which approach is most appropriate?

A. Enable distributed tracing with OpenTelemetry
B. Increase the Cosmos DB consistency level
C. Create an additional Azure Container Registry
D. Configure a Service Bus dead-letter queue

Answer: A

Explanation: Distributed tracing is particularly valuable when an application spans multiple services. OpenTelemetry instrumentation can provide trace information that helps developers follow a request across service boundaries and identify where latency is introduced.

Go to the AI-200 Exam Prep Hub main page