Microsoft Updated AI-200 Exam Questions and Answers by arisha

Trigger scaling based on queue depth: Azure Service Bus scaler

Deallocate instances when the message queue is empty: Minimum replicas = 0

Prevent uncontrolled burst scaling: Maximum replicas = 10

The batch retraining workload must scale according to queue length , so the correct KEDA trigger is the Azure Service Bus scaler . KEDA integrates with Azure Service Bus and monitors queue or subscription metrics, allowing AKS workloads to scale according to the number of pending messages rather than CPU utilization or HTTP request concurrency. Microsoft documents KEDA as the event-driven autoscaling mechanism for AKS and specifically supports Azure-based scalers for queue-driven workloads.

To meet the requirement to deallocate workload instances when no messages remain, configure minimum replicas = 0 . KEDA supports scale-to-zero for event-driven workloads, which is particularly appropriate for intermittent batch or machine-learning processing because no pods need to remain running while the queue is empty. Microsoft specifically identifies scale-to-zero as a KEDA capability and recommends it for sporadic ML workloads where cost optimization is important.

Finally, configure maximum replicas = 10 . A finite maximum replica count establishes an explicit upper scaling boundary, preventing large queue bursts from creating an uncontrolled number of worker replicas and protecting both infrastructure cost and downstream services.

Study Guide references: AKS → KEDA; Azure Service Bus event-driven scaling; minReplicaCount; maxReplicaCount; scale-to-zero; autoscaling limits.

The correct solution is to implement connection pooling , ideally by using the built-in PgBouncer capability in Azure Database for PostgreSQL Flexible Server. Connection pooling allows many concurrent application requests to share and reuse a smaller set of established PostgreSQL server connections instead of repeatedly opening and closing database sessions. Microsoft notes that creating a new PostgreSQL connection for each operation consumes server resources because each connection involves its own backend process. Reusing pooled connections therefore reduces connection overhead, lowers CPU and memory consumption, and improves throughput for high-concurrency workloads.

This directly matches Fabrikam ' s stated requirement that database connections support high concurrency with minimal latency through connection optimization . PgBouncer can efficiently multiplex large numbers of client connections onto fewer PostgreSQL connections, particularly in transaction pooling mode.

Increasing max_connections is not the preferred solution because each additional PostgreSQL connection consumes memory and other resources; Microsoft explicitly recommends PgBouncer instead when more concurrent connections are required. Increasing shared_buffers addresses caching and memory allocation rather than connection-management overhead. Read replicas can scale read workloads, but they do not optimize the application ' s connection lifecycle.

Study Guide references: Azure Database for PostgreSQL Flexible Server → connection pooling; PgBouncer; connection management and high-concurrency performance.

The batch embedding workload is planned to run in Azure Kubernetes Service (AKS) , and Kubernetes workloads should be defined declaratively by using YAML manifest files . Microsoft states that a Kubernetes manifest defines the desired state of cluster resources, including Deployments, Jobs, Services, ConfigMaps, and other Kubernetes objects. These manifests can then be deployed by using kubectl apply -f < manifest > .yaml.

For this case, YAML is particularly appropriate because the technical requirements emphasize repeatable, version-controlled, automated deployments . A batch vector embedding regeneration process would typically be represented as a Kubernetes workload such as a Job or another batch-oriented resource, with its configuration committed to Git alongside the rest of the deployment definitions.

kubectl run and kubectl create are imperative commands and are less appropriate for a controlled Git-based deployment model because they do not inherently preserve the complete desired-state definition as source-controlled configuration. XML is not the standard Kubernetes manifest format. az aks commands are primarily used to provision and manage the AKS cluster itself rather than declaratively define application workloads running inside the cluster.

Therefore, the correct choice is YAML-formatted Kubernetes manifest files .

Study Guide references: Azure Kubernetes Service → Kubernetes manifests; declarative deployments; kubectl apply; Git-based workload configuration.

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