Amazon
Anthropic
Avaya
Cisco
CompTIA
CrowdStrike
EC-Council
EXIN
Fortinet
Google
ISC
ISC2
ITIL
Juniper
Microsoft
NVIDIA
Okta
Palo Alto Networks
Salesforce
SAP
All Vendors

Microsoft Developing AI Cloud Solutions on Azure AI-200 Dumps in PDF

Free Microsoft AI-200 Real Questions (page: 14)

AI-200 PDF — 140 Questions

DRAG DROP (Drag and Drop is not supported)
You are deploying an AI service to ACA.
The service must retrieve secrets securely from Key Vault by using managed identity.
You need to configure secure access.
Which three 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.
Select and Place:

  1. See Explanation section for answer.

Answer(s): A

Explanation:





Step 1: Grant the Key Vault Secrets User role to the managed identity This uses Azure's modern role-based access control (RBAC) to give the application data-plane permission to read the secret values.
Step 2: Retrieve the secret by using the SDK Once authorized, the application code securely pulls the secret using libraries like the Azure Key Vault secret client library (such as SecretClient alongside DefaultAzureCredential).
Step 3: Assign a system-assigned managed identity Enabling a system-assigned identity provides the Azure Container App (ACA) with its own credentials managed automatically by Microsoft Entra ID, completely eliminating hardcoded credentials.


Reference:

https://learn.microsoft.com/en-us/azure/key-vault/general/tutorial-net-create-vault-azure-web-app




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
-The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
-Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
-Semantic retrieval uses metadata filtering combined with vector similarity search.
-Azure Managed Redis is used as a caching layer.
-Front-end and API workloads are deployed to Azure Container Apps (ACA).
-Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
-Container images are stored in Azure Container Registry (ACR).
-CI/CD uses ACR Tasks to build images on commit.
-ACA environments support revision management.
-AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
-Logs are collected in Azure Monitor.
-Teams inspect container logs and Kubernetes events when troubleshooting.
-Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end-users, even during unpredictable seasonal traffic spikes. Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs. Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction. Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets. Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load. Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints. Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization. Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete. Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates. Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited. Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy. Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero. CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits. Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.

DRAG DROP (Drag and Drop is not supported)
You need to implement the semantic retrieval workflow for the recommendation engine to meet the technical and performance requirements of Fabrikam Inc.
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.
Select and Place:

  1. See Explanation section for answer.

Answer(s): A

Explanation:





Scenario: Current: The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
Step 1: Define Table Schema with vector and metadata columns Schema configuration: Establish the PostgreSQL table structure using the pgvector extension to store both the product metadata and the high-dimensional embedding vectors.
Step 2: Configure a Hierachical Navigable Small World (HNSW) index on the embedding vector columns Configure Vector Index HNSW indexing: Implement a Hierarchical Navigable Small World (HNSW) index rather than a B-tree index, as standard B-tree indexing cannot index multi-dimensional vector embeddings for similarity searches.
An HNSW (Hierarchical Navigable Small World) index is the correct choice for the embedding vector columns in this scenario, while a B-tree index is entirely unsuited for vector similarity search.
Step 3: Load embedding vectors and associated product metadata Populate Database Data ingestion: Load the pre-computed embedding vectors along with their corresponding product metadata into the newly indexed table.
Step 4: Perform a similarity search using a WHERE clause and the <=> operator Query Similar Items Similarity search: Execute vector similarity queries using the <=> operator (which denotes cosine distance in pgvector) to find and return the closest product recommendations.


Reference:

https://mobisoftinfotech.com/resources/blog/enhancing-rag-generative-ai-postgresql-hnsw-indexes




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
-The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
-Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
-Semantic retrieval uses metadata filtering combined with vector similarity search.
-Azure Managed Redis is used as a caching layer.
-Front-end and API workloads are deployed to Azure Container Apps (ACA).
-Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
-Container images are stored in Azure Container Registry (ACR).
-CI/CD uses ACR Tasks to build images on commit.
-ACA environments support revision management.
-AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
-Logs are collected in Azure Monitor.
-Teams inspect container logs and Kubernetes events when troubleshooting.
-Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end-users, even during unpredictable seasonal traffic spikes. Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs. Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction. Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets. Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load. Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints. Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization. Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete. Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates. Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited. Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy. Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero. CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits. Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.

You need to optimize vector search queries based on the technical requirements.
What should you do?

  1. Create a B-tree index on metadata filter columns.
  2. Increase the max_connections parameter.
  3. Increase the shared_buffers setting.
  4. Create an IVFFlat index on the embedding column.

Answer(s): A

Explanation:

Scenario: Technical requirements Performance: Semantic search latency must remain under 200 milliseconds at peak load. *-> Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints.
--To optimize vector similarity queries that must be performed only against products satisfying mandatory metadata constraints, you should Create a B-tree index on metadata filter columns.
1. Evaluate Query Execution OrderIn PostgreSQL with pgvector, combining metadata filters with vector similarity searches often triggers a multi-stage execution plan.
When metadata filtering is highly restrictive, creating a B-tree index allows the database engine to quickly narrow down the row scanned before or during the vector evaluation, preventing a costly full-table scan.
2. Assess Indexing Trade-offs B-tree Index (Metadata): Directly addresses the requirement that vector calculations must be performed only against products satisfying mandatory metadata constraints. It optimizes the metadata filtering step, significantly reducing compute overhead and isolating the target rows for vector processing.
IVFFlat Index (Vector): While an IVFFlat index speeds up high-dimensional approximate nearest neighbor (ANN) searches, it divides vectors into lists. If a metadata filter is applied after an IVFFlat index scan, it can lead to severe recall degradation or inaccurate results because rows matching the metadata might reside in unsearched vector lists. (
Note: For newer workloads, HNSW is generally preferred over IVFFlat for better recall and performance, but regular B-trees remain vital for the metadata layer).
3. Ensure Index Residency in RAM
By isolating the dataset using a compact B-tree index on metadata columns, you minimize the active working set. This helps fulfill your operational requirement to ensure that high-dimensional vector indexes and target rows remain resident in RAM for efficient mathematical throughput.


Reference:

https://www.applied-ai.com/briefings/enterprise-rag-architecture/




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
-The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
-Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
-Semantic retrieval uses metadata filtering combined with vector similarity search.
-Azure Managed Redis is used as a caching layer.
-Front-end and API workloads are deployed to Azure Container Apps (ACA).
-Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
-Container images are stored in Azure Container Registry (ACR).
-CI/CD uses ACR Tasks to build images on commit.
-ACA environments support revision management.
-AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
-Logs are collected in Azure Monitor.
-Teams inspect container logs and Kubernetes events when troubleshooting.
-Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end-users, even during unpredictable seasonal traffic spikes. Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs. Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction. Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets. Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load. Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints. Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization. Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete. Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates. Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited. Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy. Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero. CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits. Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.

HOTSPOT (Drag and Drop is not supported)
You need to optimize secure database connectivity from the containerized Recommendation API.
How should you configure the application? To answer, select the appropriate options in the answer area.
Note: Each correct selection is worth one point.
Hot Area:

  1. See Explanation section for answer.

Answer(s): A

Explanation:




Box 1: Use managed identity authentication. Scenario: Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited.'
Box 2: Use a connection pooling library Scenario: Environment: Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
To support high-concurrency requests with minimal latency on Azure Database for PostgreSQL, the best action is to use a connection pooling library (or leverage Azure's built-in PgBouncer feature).
Eliminates Connection Overhead: PostgreSQL utilizes a process-per-connection model. Forking a new backend process for every incoming request introduces substantial CPU and memory overhead, severely degrading latency under high concurrency. A connection pool keeps a warm set of reusable database sessions active.
Optimized for Azure: Microsoft provides a built-in managed PgBouncer integration for Azure Database for PostgreSQL. Enabling it in transaction mode allows the database to accept thousands of concurrent client connections while keeping actual backend processes lean and stable
Box 3: Configure a maximum pool size Configure a maximum pool size is the best action to directly protect database stability during sudden traffic spikes.
Prevents Resource Exhaustion: Traffic spikes naturally lead to a surge in connection requests. Unchecked connections consume substantial RAM and CPU overhead, which can crash the database or trigger severe latency. Limiting the pool size stops the "thundering herd" problem
Acts as a Shock Absorber: When the pool hits its maximum limit, extra client requests are safely queued at the application or connection pooling layer (like Azure's built-in PgBouncer proxy) rather than overwhelming the database backend


Reference:

https://docs.azure.cn/en-us/postgresql/connectivity/concepts-pgbouncer https://learn.microsoft.com/en-au/answers/questions/5884412/best-practise-azure-postgresql-flexible-server-max




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
-The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
-Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
-Semantic retrieval uses metadata filtering combined with vector similarity search.
-Azure Managed Redis is used as a caching layer.
-Front-end and API workloads are deployed to Azure Container Apps (ACA).
-Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
-Container images are stored in Azure Container Registry (ACR).
-CI/CD uses ACR Tasks to build images on commit.
-ACA environments support revision management.
-AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
-Logs are collected in Azure Monitor.
-Teams inspect container logs and Kubernetes events when troubleshooting.
-Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end-users, even during unpredictable seasonal traffic spikes. Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs. Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction. Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets. Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load. Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints. Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization. Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete. Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates. Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited. Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy. Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero. CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits. Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.

You need to improve throughput for concurrent application requests to PostgreSQL.
What should you implement?

  1. Implement connection pooling.
  2. Increase shared_buffers.
  3. Enable read replicas.
  4. Increase max_connections.

Answer(s): A

Explanation:

To improve throughput for highly concurrent application requests in this architecture, you should implement connection pooling.
PostgreSQL follows a process-based architecture where each client connection spawns a separate backend process. This consumes significant memory and CPU overhead during high concurrency. Connection pooling
(using tools like PgBouncer or Azure's built-in pooler) allows containerized microservices to reuse a fixed set of database connections. This drastically reduces connection overhead, prevents database exhaustion, and maximizes throughput for short, rapid API queries like vector similarity searches.


Reference:

https://medium.com/@srajanpathak45/a-principal-engineers-guide-to-postgresql-and-modern-alternatives-e8920fd6269a




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
-The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
-Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
-Semantic retrieval uses metadata filtering combined with vector similarity search.
-Azure Managed Redis is used as a caching layer.
-Front-end and API workloads are deployed to Azure Container Apps (ACA).
-Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
-Container images are stored in Azure Container Registry (ACR).
-CI/CD uses ACR Tasks to build images on commit.
-ACA environments support revision management.
-AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
-Logs are collected in Azure Monitor.
-Teams inspect container logs and Kubernetes events when troubleshooting.
-Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end-users, even during unpredictable seasonal traffic spikes. Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs. Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction. Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets. Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load. Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints. Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization. Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete. Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates. Identity: Use managed identities for all service-to-service and service-to-database authentication. Plain-text credentials in configuration files are strictly prohibited. Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy. Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero. CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits. Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.

DRAG DROP (Drag and Drop is not supported)
You need to configure the Redis integration for the Recommendation API.
Which configurations should you use? 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.
Select and Place:

  1. See Explanation section for answer.

Answer(s): A

Explanation:





Scenario, Application: Azure Managed Redis is used as a caching layer.
Box 1: Configure the Time to Live (TTL) on each cache key You must configure the Time to Live (TTL) on each cache key to meet this requirement. Azure Managed Redis (like standard Redis) does not support a global, database-wide default TTL configuration for newly created keys.
Scenario: Technical requirements: Caching: Redis cache entries must expire automatically after 10 minutes.
Box 2: Publish invalidation events to a Redis channel
Publishing invalidation events to a Redis Pub/Sub channel is a highly effective, standard architecture to invalidate cache entries across microservices or application nodes. It establishes a reactive, event-driven backplane that ensures system data integrity without requiring tight coupling between your database updates and web servers.
Scenario: Technical requirements: Implement a reactive mechanism to invalidate cache entries upon metadata updates.
Box 3: Implement the cache-aside pattern with lazy loading To meet your search latency target for recurring product requests, you should implement the cache-aside pattern with lazy loading.
Directly reduces latency: Lazy loading ensures that frequently requested product data is kept in memory (Redis), allowing subsequent recurring requests to bypass the slower database completely.
Optimizes memory usage: Data is only loaded into the cache when actually requested, preventing your Azure Managed Redis instance from filling up with rarely accessed product data.


Reference:

https://learn.microsoft.com/en-us/azure/architecture/databases/architecture/write-through-caching-azure-sql-managed-redis https://www.gigson.co/blog/what-is-redis-a-beginners-guide-to-in-memory-caching




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
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.

HOTSPOT (Drag and Drop is not supported)
You need to configure vector embedding updates according to the business and technical requirements.
Which configurations should you use? To answer, select the appropriate options in the answer area.
Note: Each correct selection is worth one point.
Hot Area:

  1. See Explanation section for answer.

Answer(s): A

Explanation:





Business Requirements: Embeddings for new or updated Azure Cosmos DB for NoSQL-hosted documents must be automatically generated. Technical Requirements: Vector similarity search must use embeddings stored in Azure Cosmos DB for NoSQL.
Box 1: Change feed processor The Change feed processor is the correct component to configure for identifying document changes that should trigger vectorization.
This feature in Azure Cosmos DB provides a reliable, distributed, and scalable way to listen to a constant stream of changes (inserts and updates) within a container. It allows you to process these modifications in real-time, making it the perfect trigger for automated workflows like sending new text to an embedding model.
Box 2: Lease Container The lease container is the component you configure to coordinate and horizontally scale out the change feed-driven vectorization processing across multiple workers or compute instances.
The Lease Container acts as state storage, tracks checkpoints, and distributes partition keys across parallel compute workers (such as Azure Functions or custom change feed processors) to scale out throughput processing safely without duplicate work.
Incorrect: RU Throughput: Dictates the maximum performance limit, but provisioning RUs alone does not orchestrate or scale out multiple processing workers.
Consistency Level: Affects data replication guarantees and read/write ordering, not parallel processing distribution.


Reference:

https://blog.nashtechglobal.com/managing-record-changes-with-change-feed-in-azure-cosmos-db/




This is a case study. Case studies are not timed separately from other exam sections. You can use as much exam time as you would like to complete each case study. However, there might be additional case studies or other exam sections. Manage your time to ensure that you can complete all the exam sections in the time provided. Pay attention to the Exam Progress at the top of the screen so you have sufficient time to complete any exam sections that follow this case study.
To answer the case study questions, you will need to reference information that is provided in the case. Case studies and associated questions might contain exhibits or other resources that provide more information about the scenario described in the case. Information provided in an individual question does not apply to the other questions in the case study.
A Review Screen will appear at the end of this case study. From the Review Screen, you can review and change your answers before you move to the next exam section. After you leave this case study, you will NOT be able to return to it.
To start the case study
To display the first question in this case study, select the "Next" button. To the left of the question, a menu provides links to information such as business requirements, the existing environment, and problem statements. Please read through all this information before answering any questions.
When you are ready to answer a question, select the "Question" button to return to the question.
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 address the known issue resulting from vector similarity queries.
Which two actions should you perform? Each correct answer presents part of the solution.
Note: Each correct selection is worth one point.

  1. Add a composite index on the vector fields and metadata properties of the container.
  2. Modify the indexing precision of the vector fields.
  3. Set the account consistency level to Strong.
  4. Change the vector index type from Oat to quantizedFlat or diskANN.

Answer(s): B,D

Explanation:

Known Issues: RU consumption spikes during vector similarity queries.
To address the RU (Request Unit) consumption spikes during vector similarity queries in Azure Cosmos DB, you should perform the following two steps: Modify the indexing precision of the vector fields Change the vector index type from flat to quantizedFlat or diskANN
Indexing Precision Tuning: Modifying parameters like vector quantization (e.g., configuring quantizedByteSize) alters the size and precision of the stored vector elements. Lowering the precision decreases memory usage and index size, allowing faster searches that consume far fewer RUs at the expense of marginal recall accuracy.
Index Type Modification: A standard flat index conducts a brute-force k-nearest neighbors (kNN) exact search across every document. This requires vast computational overhead and causes RU spikes as your dataset grows. Transitioning to quantizedFlat or diskANN leverages compression techniques and advanced graph-traversal algorithms to perform approximate nearest neighbor (ANN) searches, dropping query latency and compute costs significantly.


Reference:

https://learn.microsoft.com/en-us/azure/cosmos-db/gen-ai/vector-search-performance-tips



PDF
Viewing page 14 of 17

Share your comments for Microsoft AI-200 exam with other users:

T
Tao
11/20/2023 8:53:00 AM

there is an incorrect word in the problem statement. for example, in question 1, there is the word "speci c". this is "specific. in the other question, there is the word "noti cation". this is "notification. these mistakes make this site difficult for me to use.

Anonymous
P
patricks
10/24/2023 6:02:00 AM

passed my az-120 certification exam today with 90% marks. studied using the dumps highly recommended to all.

Anonymous
A
Ananya
9/14/2023 5:17:00 AM

i need it, plz make it available

UNITED STATES
J
JM
12/19/2023 2:41:00 PM

q47: intrusion prevention system is the correct answer, not patch management. by definition, there are no patches available for a zero-day vulnerability. the way to prevent an attacker from exploiting a zero-day vulnerability is to use an ips.

UNITED STATES
R
Ronke
8/18/2023 10:39:00 AM

this is simple but tiugh as well

Anonymous
C
CesarPA
7/12/2023 10:36:00 PM

questão 4, segundo meu compilador local e o site https://www.jdoodle.com/online-java-compiler/, a resposta correta é "c" !

UNITED STATES
J
Jeya
9/13/2023 7:50:00 AM

its very useful

INDIA
T
Tracy
10/24/2023 6:28:00 AM

i mastered my skills and aced the comptia 220-1102 exam with a score of 920/1000. i give the credit to for my success.

Anonymous
J
James
8/17/2023 4:33:00 PM

real questions

UNITED STATES
A
Aderonke
10/23/2023 1:07:00 PM

very helpful assessments

UNITED KINGDOM
S
Simmi
8/24/2023 7:25:00 AM

hi there, i would like to get dumps for this exam

AUSTRALIA
J
johnson
10/24/2023 5:47:00 AM

i studied for the microsoft azure az-204 exam through it has 100% real questions available for practice along with various mock tests. i scored 900/1000.

GERMANY
M
Manas
9/9/2023 1:48:00 AM

please upload 1z0-1072-23 exam dups

UNITED STATES
S
SB
9/12/2023 5:15:00 AM

i was hoping if you could please share the pdf as i’m currently preparing to give the exam.

Anonymous
J
Jagjit
8/26/2023 5:01:00 PM

i am looking for oracle 1z0-116 exam

UNITED STATES
S
S Mallik
11/27/2023 12:32:00 AM

where we can get the answer to the questions

Anonymous
P
PiPi Li
12/12/2023 8:32:00 PM

nice questions

NETHERLANDS
D
Dan
8/10/2023 4:19:00 PM

question 129 is completely wrong.

UNITED STATES
G
gayathiri
7/6/2023 12:10:00 AM

i need dump

UNITED STATES
D
Deb
8/15/2023 8:28:00 PM

love the site.

UNITED STATES
M
Michelle
6/23/2023 4:08:00 AM

can you please upload it back?

Anonymous
A
Ajay
10/3/2023 12:17:00 PM

could you please re-upload this exam? thanks a lot!

Anonymous
H
him
9/30/2023 2:38:00 AM

great about shared quiz

Anonymous
S
San
11/14/2023 12:46:00 AM

goood helping

Anonymous
W
Wang
6/9/2022 10:05:00 PM

pay attention to questions. they are very tricky. i waould say about 80 to 85% of the questions are in this exam dump.

UNITED STATES
M
Mary
5/16/2023 4:50:00 AM

wish you would allow more free questions

Anonymous
T
thomas
9/12/2023 4:28:00 AM

great simulation

Anonymous
S
Sandhya
12/9/2023 12:57:00 AM

very g inood

Anonymous
A
Agathenta
12/16/2023 1:36:00 PM

q35 should be a

Anonymous
M
MD. SAIFUL ISLAM
6/22/2023 5:21:00 AM

sap c_ts450_2021

Anonymous
S
Satya
7/24/2023 3:18:00 AM

nice questions

UNITED STATES
S
sk
5/13/2023 2:10:00 AM

ecellent materil for unserstanding

INDIA
G
Gerard
6/29/2023 11:14:00 AM

good so far

Anonymous
L
Limbo
10/9/2023 3:08:00 AM

this is way too informative

BOTSWANA
AI Tutor 👋 I’m here to help!