Study with AI-200 most valid questions & verified answers

Drag and Drop Question
You are building a back-end pipeline that receives AI inference requests.
The pipeline must perform the following actions:
- Publish a message so that multiple independent consumers receive it.
- Process messages in first-in, first-out (FIFO) order.
- Isolate any failed messages.
You need to configure the appropriate Service Bus entities.
How should you configure the Service Bus entities? To answer, move the appropriate configurations to the correct requirements. You may use each configuration once, more than once, or not at all. You may need to move the split bar between panes or scroll to view content.
NOTE: Each correct selection is worth one point.

Explanation:
Box 1: topic
You should use an Azure Service Bus Topic to publish the message.
In a pub/sub architecture, the topic acts as the single destination where the sender publishes the message.
Box 2: queue
You should use a dedicated FIFO queue for this purpose.
While a standard queue allows parallel processing that can disrupt the arrival order, a strict FIFO (First-In, First-Out) queue guarantees that your AI inference requests are processed in the exact order they are received.
Order Preservation: Standard message queues only guarantee "best-effort" ordering. FIFO queues ensure strict sequential processing.
Exactly-Once Processing: FIFO queues inherently prevent duplicate message delivery. This prevents running the same costly AI inference twice.
Concurrency Control: You can limit or throttle consumers. This prevents overwhelming your AI models or GPUs.
Box 3: dead-letter queue
A dead-letter queue (DLQ) is the exact industry-standard pattern and correct architectural choice to isolate failed messages in an AI inference pipeline. It captures messages that fail processing repeatedly due to errors like model timeouts, malformed input payloads, or downstream GPU memory crashes.
Prevents Blockages: Stops bad requests from clogging the main queue and halting pipeline throughput.
Enables Debugging: Preserves the exact failed payload and error metadata for post-mortem analysis.
Protects Resources: Keeps infrastructure from getting stuck in endless retry loops on broken data.
Reference:
https://wearenotch.com/blog/azure-service-bus-tips-to-optimize-functions/

You develop an AI application that stores telemetry documents in Azure Cosmos DB for NoSQL.
Each document contains 30 properties. Queries filter only on deviceId and timestamp.
Write operations consume more RUs than expected.
You need to reduce RU consumption for write operations while maintaining query performance.
What should you do?

• A. Enable strong consistency for all requests.
• B. Migrate to a different partition key.
• C. Exclude unused properties from indexing.
• D. Configure selective indexing on queried properties.

Explanation: Only visible for Easy4Engine members. You can sign-up / login (it's free).

Drag and Drop Question
You are developing a Python application that reads data from Azure Cosmos DB for NoSQL by using the azure-cosmos SDK.
You need to connect to an existing account and run a SQL query against an existing container.
Which four actions should you perform in sequence? To answer, move the appropriate actions from the list of actions to the answer area and arrange them in the correct order.

Explanation:
In the azure-cosmos Python SDK, you do not use an explicit "InitializeDatabaseProxy" method.
Instead, you use the client to get a database reference, and then use that database reference to get a container reference.
Step 1: Initialize CosmosClient
You must first establish the root connection using the client object with your account endpoint and credentials.
Step 2: Specify the database name
From the client, you call client.get_database_client(database_name) to target your specific database resource.
Step 3: Obtain the container reference
From the database proxy object, you call database.get_container_client(container_name) to reference the specific data container.
Step 4: Run the Query
Finally, you execute the SQL operation directly on that container using container.query_items().
Reference:
https://learn.microsoft.com/en-us/azure/cosmos-db/quickstart-python

Your application must classify uploaded product images into one of 40 custom categories specific to your business (e.g., proprietary part numbers). What should you use?

• A. Azure AI Document Intelligence
• B. Azure AI Face API
• C. Azure AI Custom Vision (image classification)
• D. Azure AI Vision prebuilt image analysis

Explanation: Only visible for Easy4Engine members. You can sign-up / login (it's free).

Case Study 2 - Proseware Inc.
Background
Proseware Inc. develops AI-powered knowledge management solutions for enterprise customers.
The company is modernizing its platform to support semantic search, intelligent document retrieval, and real-time partner integrations.
The engineering team uses Python and Azure SDKs. The architecture is being redesigned to support containerized microservices, vector search workloads, and serverless backend processing.
Planned Application Architecture
Microservices are containerized by using Docker.
Code for containerized microservices and Azure Function apps is developed locally but stored in a GitHub repository.
Custom images for containerized microservices are stored in Azure Container Registry (ACR).
Base images are stored in Docker Hub. Custom images must be rebuilt automatically whenever their base images are updated.
Azure Cosmos DB for NoSQL stores documents, metadata, and vector embeddings.
Azure Functions generate vector embeddings of Azure Cosmos DB for NoSQL-hosted documents and send messages to Service Bus to trigger search index updates.
Azure Container Apps (ACA) apps host backend API services that provide semantic search across Azure Cosmos DB for NoSQL documents. API services process Service Bus messages and update search indexes.
Azure Kubernetes Service (AKS) processes batch vector embedding regeneration for existing Azure Cosmos DB for NoSQL documents (whenever the embedding model is changed).
An extranet-facing containerized webhook allows business partners to submit documents to be processed by internal AI workflows for semantic search and retrieval.
Monitoring
Telemetry generated by Azure resources is sent to Azure Monitor.
A Log Analytics workspace is used to collect ACA apps logs, AKS container logs, and Azure Functions apps logs.
Monitoring of Azure Functions is currently implemented by using Azure Application Insights SDK instrumentation.
Business Requirements
Embeddings for new or updated Azure Cosmos DB for NoSQL-hosted documents must be automatically generated.
Backend API services must scale automatically during business hours.
Cold start delay of backend APIs must be minimized.
Secrets must be stored outside of container images.
Developers must be able to correlate telemetry across Azure Functions hosts and apps.
All tracing must be implemented by using OpenTelemetry SDK instrumentation.
Development efforts must be minimized.
Technical Requirements
Container images must be built automatically and validated before code updates are merged into the main branch.
Image build automation must run inside the Azure Container Registry, eliminating dependency on local developer machines and external build services.
Dependency of image builds on local developer machines must be eliminated.
Event-driven scaling in ACA must occur based on the number of pending messages in the Azure Service Bus queue.
Azure Cosmos DB for NoSQL RU consumption must be minimized.
Vector similarity search must use embeddings stored in Azure Cosmos DB for NoSQL.
The partner-facing containerized webhook service must run on Azure App Service.
Secrets must NOT be stored in container images, source control, or application configuration directly. They must be accessed securely at runtime.
All secrets must be stored centrally in Azure Key Vault and accessed at runtime through a managed identity.
Azure App Service must supply secrets at runtime without relying on external services.
Resources and workloads must be deployed by using Bicep templates through an automated, version-controlled pipeline. Local and command-line deployments must be eliminated to ensure repeatable, auditable deployments.
Known Issues
RU consumption spikes during vector similarity queries.
You need to deploy a batch embedding workload according to the planned application architecture.
What should you use?

• A. XML-formatted files
• B. YAML-formatted files
• C. kubectl run and create commands
• D. az aks commands

Explanation: Only visible for Easy4Engine members. You can sign-up / login (it's free).