Free Developing AI Cloud Solutions on Azure Practice Questions

Define a table schema with vector and metadata columns.

Load embedding vectors and associated product metadata.

Configure a Hierarchical Navigable Small World (HNSW) index on the embedding vector columns.

Perform a similarity search using a WHERE clause and the < = > operator.

The workflow must first establish a PostgreSQL schema containing both the pgvector embedding column and the product metadata required for filtering. The embeddings and their associated metadata are then bulk-loaded. This ordering is important because Microsoft recommends loading data before creating vector indexes ; creating the index afterward provides faster ingestion and a more optimal index layout.

After loading, configure an HNSW index on the embedding column. HNSW is an approximate-nearest-neighbor index supported by pgvector and provides a strong speed/recall tradeoff for low-latency vector retrieval. Microsoft specifically documents HNSW for efficient cosine-distance searches in Azure Database for PostgreSQL.

Finally, execute the retrieval query so that mandatory product metadata constraints are applied through a WHERE clause , while vector similarity is evaluated with the < = > cosine-distance operator . This satisfies Fabrikam ' s requirement to calculate similarity only for eligible products.

A B-tree index is not an ANN vector index, and increasing Redis memory does not implement PostgreSQL semantic retrieval.

Study Guide references: Azure Database for PostgreSQL → pgvector, HNSW indexing, bulk-load optimization, vector similarity operators, metadata-filtered retrieval.

Comply with the defined expiration policy for recommendation results: Configure Time to Live on each cache key.

Support the data integrity and freshness requirement for catalog updates: Publish invalidation events to a Redis channel.

Meet the search latency target for recurring product requests: Implement cache-aside pattern with lazy loading.

The 10-minute expiration requirement should be implemented by configuring a Time to Live (TTL) on each Redis cache key. Redis automatically removes a key after its assigned expiration interval, ensuring recommendation results cannot remain cached indefinitely. Microsoft documents expiration as a standard mechanism for preventing cached data from becoming stale.

For catalog changes, Fabrikam explicitly requires a reactive invalidation mechanism . Publishing invalidation events to a Redis Pub/Sub channel allows application components to notify subscribers immediately when product metadata or pricing changes. Redis Pub/Sub broadcasts messages to channel subscribers, which can then invalidate affected cache entries instead of waiting for TTL expiration.

For repeated recommendation queries, implement the cache-aside pattern with lazy loading . The application first checks Redis; on a cache hit, results are returned from the low-latency in-memory cache. On a miss, the application retrieves data from PostgreSQL, places the result in Redis, and returns it. Microsoft identifies cache-aside as an appropriate pattern for frequently read data and explicitly notes that Azure Managed Redis provides low-latency, high-throughput access.

Redis RDB persistence is unnecessary for these requirements because the cache is an optimization layer rather than the authoritative data store.

Study Guide references: Azure Managed Redis → cache-aside pattern; TTL/expiration; Pub/Sub; cache invalidation and data freshness.

Meet the 200-ms semantic search latency requirement: Increase compute vCores.

Optimize the environment for high-dimensional pgvector index residency: Increase memory allocation.

Support the continuous ingestion of transaction-based embeddings: Enable storage autoscale.

For the strict sub-200-ms vector-search latency target, increasing compute vCores is the appropriate choice. Vector similarity operations are computationally intensive, and additional CPU capacity improves mathematical throughput and parallel query execution. Microsoft’s pgvector guidance emphasizes query-plan optimization, ANN indexes such as HNSW, and sufficient compute resources when optimizing vector workloads.

For high-dimensional pgvector index residency , increase memory allocation . HNSW provides strong query-performance characteristics but consumes more memory than IVFFlat. Keeping frequently accessed vector index structures in memory minimizes disk access and materially improves latency. Microsoft explicitly notes that HNSW requires more memory while providing a better speed/recall tradeoff.

For the continuous ingestion of millions of embeddings, enable storage autoscale . Azure Database for PostgreSQL Flexible Server can automatically increase allocated storage as capacity approaches configured thresholds, avoiding an out-of-storage condition as data volumes grow. Microsoft recommends storage autogrow for workloads whose storage demand can increase dynamically.

Increasing max_connections does not directly improve vector computation or index residency, read replicas primarily scale reads, and backup retention does not address ingestion capacity.

Study Guide references: Azure Database for PostgreSQL Flexible Server → pgvector performance optimization; compute and memory sizing; HNSW indexing; storage autogrow.

Detailed Explanation: The objective is to reduce RU consumption from vector similarity queries. Microsoft guidance identifies vector numeric precision and vector-index selection as major cost and performance levers. Using a lower supported vector precision can reduce storage and processing cost, while quantizedFlat and DiskANN are designed to reduce latency and RU consumption compared with flat search for appropriate data sizes. Strong consistency would increase resource cost rather than solve vector-search efficiency. A regular composite index is not a substitute for the vector index. Option B should be read as reducing vector numeric precision, not changing a generic “indexing precision” setting.

Study Guide Alignment: AI data-management workloads: Cosmos DB, PostgreSQL, caching, vector storage, vector retrieval, consistency, and connection optimization.

Official Microsoft Learn References: AI-200 Study Guide | Vector search in Azure Cosmos DB | Optimize Cosmos DB vector search performance

Service fails to communicate with another service: Inspect Kubernetes service endpoints.

Pod restarts repeatedly: Inspect container logs.

Readiness probe failures are observed: Inspect Pod descriptions.

For a service-to-service communication failure , first inspect the Kubernetes service endpoints . Microsoft’s AKS troubleshooting guidance recommends verifying that the destination pod IP address and application port appear as endpoints for the Kubernetes Service. An empty or incorrect endpoint list commonly indicates a selector/label mismatch, incorrect port configuration, or unavailable backend pods.

For a pod that restarts repeatedly , inspect the container logs , including the previous container instance when necessary. Microsoft specifically recommends kubectl logs < pod > --previous for workloads that repeatedly restart because it exposes application errors and termination messages from the container immediately before the restart.

For readiness probe failures , inspect the Pod description by using kubectl describe pod. The description exposes the configured health probes, pod conditions, container state, and associated probe-failure events, allowing you to determine whether the probe path, port, timing, or application readiness behavior is incorrect. Microsoft recommends reviewing kubectl describe output when pods are not Ready or health probes are failing.

Therefore, the correct mapping is service endpoints → container logs → Pod descriptions .

Study Guide references: AKS troubleshooting; Kubernetes Services and endpoints; container logging; Pod health; readiness/liveness probes; kubectl describe and kubectl logs.

Verified Answer: 1) Instrument the application code with the OpenTelemetry SDK; 2) configure an Azure Monitor trace exporter in the OpenTelemetry SDK; 3) redeploy the instrumented services.

Detailed Explanation: Trace correlation requires the application to create OpenTelemetry spans and an exporter to send those spans to Azure Monitor. Instrumentation must therefore be present before the updated service is deployed. The previous Application Insights SDK instrumentation does not satisfy the case-study requirement that all tracing use OpenTelemetry. Configuring an OpenTelemetry view is unrelated to basic distributed-trace export, and calling TrackEvent is an Application Insights SDK pattern rather than the required OpenTelemetry approach.

Study Guide Alignment: Security and operations: Key Vault, App Configuration, managed identity, OpenTelemetry, Azure Monitor, and KQL-based troubleshooting.

Official Microsoft Learn References: AI-200 Study Guide | Enable Azure Monitor OpenTelemetry