Sample questions
Microsoft Azure Developer Associate AZ-204 practice questions
An app must store relational state and perform transactions across multiple tables with T-SQL support. Which Azure data service should the developer choose?
Trap 1: Azure Queue Storage
Queue Storage is for messaging, not relational state.
Trap 2: Azure Cache for Redis
Redis is an in-memory cache and not the primary relational database.
Trap 3: Azure Blob Storage
Blob Storage is object storage and does not provide relational transactions.
- A
Azure Queue Storage
Why wrong: Queue Storage is for messaging, not relational state.
- B
Azure SQL Database
Azure SQL Database supports relational schema, T-SQL, and transactions.
- C
Azure Cache for Redis
Why wrong: Redis is an in-memory cache and not the primary relational database.
- D
Azure Blob Storage
Why wrong: Blob Storage is object storage and does not provide relational transactions.
You are monitoring an Azure App Service using Application Insights. You notice that the server response time is high for certain requests. You need to drill down to see which external dependencies (like databases or APIs) are causing the delay. Which Application Insights feature should you use?
Trap 1: Live Metrics
Live Metrics provides real-time monitoring of metrics and requests but does not offer detailed dependency breakdowns.
Trap 2: Application Map
Application Map visualizes the dependencies and flow between components but does not show detailed timing of each dependency call.
Trap 3: Snapshot Debugger
Snapshot Debugger takes snapshots of exception code; it is not used for analyzing slow responses.
- A
Live Metrics
Why wrong: Live Metrics provides real-time monitoring of metrics and requests but does not offer detailed dependency breakdowns.
- B
Application Map
Why wrong: Application Map visualizes the dependencies and flow between components but does not show detailed timing of each dependency call.
- C
Profiler
Profiler captures per-request execution traces, including time spent in external dependencies, helping identify which dependency is slow.
- D
Snapshot Debugger
Why wrong: Snapshot Debugger takes snapshots of exception code; it is not used for analyzing slow responses.
Which TWO services can be used to implement a publish-subscribe messaging pattern in Azure?
Trap 1: Azure Storage Queues
Storage Queues are for point-to-point messaging.
Trap 2: Azure Event Hubs
Event Hubs is for event streaming, not pub-sub.
Trap 3: Azure Queue Storage
Queue Storage is for point-to-point messaging.
- A
Azure Storage Queues
Why wrong: Storage Queues are for point-to-point messaging.
- B
Azure Event Hubs
Why wrong: Event Hubs is for event streaming, not pub-sub.
- C
Azure Service Bus Topics
Service Bus Topics support pub-sub with subscriptions.
- D
Azure Event Grid
Event Grid is a pub-sub event routing service.
- E
Azure Queue Storage
Why wrong: Queue Storage is for point-to-point messaging.
You need to monitor the CPU utilization of an Azure VM in real-time and set up an alert when it exceeds 90%. Which Azure Monitor feature should you use?
Trap 1: Log Analytics Workspace
Incorrect. Log Analytics is for analyzing log data, not real-time metrics; it adds latency.
Trap 2: Application Insights
Incorrect. Application Insights focuses on application performance monitoring, not VM-level host metrics.
Trap 3: Azure Monitor for VMs
Incorrect. Azure Monitor for VMs gives health summaries but the primary metric alert creation is through Metrics Explorer.
- A
Log Analytics Workspace
Why wrong: Incorrect. Log Analytics is for analyzing log data, not real-time metrics; it adds latency.
- B
Metrics Explorer
Correct. Metrics Explorer provides near real-time platform metrics and supports creating metric alerts.
- C
Application Insights
Why wrong: Incorrect. Application Insights focuses on application performance monitoring, not VM-level host metrics.
- D
Azure Monitor for VMs
Why wrong: Incorrect. Azure Monitor for VMs gives health summaries but the primary metric alert creation is through Metrics Explorer.
You are monitoring an Azure web application with Application Insights. You notice a sudden increase in the number of failed requests. You want to be notified automatically when such anomalies occur, without manually setting static thresholds. Which Application Insights feature should you use?
Trap 1: Create a metric alert on the 'failed requests' metric with a static…
A static threshold alert would require you to set a fixed number, which may not adapt to normal variations. Smart Detection is better for anomaly detection.
Trap 2: Use Log Analytics to run a query every 5 minutes and trigger an…
Log Analytics queries can be used in log alerts, but they require you to define the query and threshold manually. Smart Detection is automated.
Trap 3: Create an availability test that periodically pings the application.
Availability tests monitor the endpoint's uptime and response, but they do not analyze anomalies in failed request patterns from real user traffic.
- A
Create a metric alert on the 'failed requests' metric with a static threshold.
Why wrong: A static threshold alert would require you to set a fixed number, which may not adapt to normal variations. Smart Detection is better for anomaly detection.
- B
Enable Smart Detection for failure anomalies.
Correct. Smart Detection automatically analyzes telemetry and alerts on anomalous patterns, such as a sudden spike in failed requests.
- C
Use Log Analytics to run a query every 5 minutes and trigger an action.
Why wrong: Log Analytics queries can be used in log alerts, but they require you to define the query and threshold manually. Smart Detection is automated.
- D
Create an availability test that periodically pings the application.
Why wrong: Availability tests monitor the endpoint's uptime and response, but they do not analyze anomalies in failed request patterns from real user traffic.
You are monitoring an Azure web app using Application Insights. You need to create a query that returns the average duration of requests for each HTTP method (GET, POST, etc.) over the last hour, sorted by duration. Which Kusto query should you use?
Trap 1: requests | summarize avg(duration) by method | order by…
Incorrect. This query lacks a time filter and would return data for the entire retention period, not just the last hour.
Trap 2: requests | summarize avg(duration) by method | sort by method asc
Incorrect. This query lacks a time filter and sorts by method name, not by average duration.
Trap 3: requests | where timestamp > ago(1h) | summarize avg(duration) by…
Incorrect. Correctly filters by time but sorts by method name instead of average duration.
- A
requests | summarize avg(duration) by method | order by avg_duration desc
Why wrong: Incorrect. This query lacks a time filter and would return data for the entire retention period, not just the last hour.
- B
requests | summarize avg(duration) by method | sort by method asc
Why wrong: Incorrect. This query lacks a time filter and sorts by method name, not by average duration.
- C
requests | where timestamp > ago(1h) | summarize avg(duration) by method | order by avg_duration desc
Correct. Filters to the last hour, summarizes by method with average duration, and orders descending by that average.
- D
requests | where timestamp > ago(1h) | summarize avg(duration) by method | sort by method
Why wrong: Incorrect. Correctly filters by time but sorts by method name instead of average duration.
An Azure web app is experiencing high memory usage. You want to collect memory dumps periodically to analyze the issue without restarting the app. Which Azure App Service diagnostic feature should you use?
Trap 1: Application Insights Profiler
Application Insights Profiler traces code execution to identify slow paths, but it does not capture memory dumps.
Trap 2: Diagnostic Settings
Diagnostic Settings streams platform logs and metrics, but it does not provide memory dump collection.
Trap 3: Auto-healing
Auto-healing automatically recycles the app based on triggers but does not collect memory dumps for analysis.
- A
Application Insights Profiler
Why wrong: Application Insights Profiler traces code execution to identify slow paths, but it does not capture memory dumps.
- B
Diagnostic Settings
Why wrong: Diagnostic Settings streams platform logs and metrics, but it does not provide memory dump collection.
- C
Application Snapshot Debugger
Application Snapshot Debugger captures memory snapshots or dumps on demand without restarting the app, enabling analysis of memory issues.
- D
Auto-healing
Why wrong: Auto-healing automatically recycles the app based on triggers but does not collect memory dumps for analysis.
An Azure App Service application has availability failures. The developer needs distributed tracing across requests and dependencies. What should be enabled?
Trap 1: Storage account static website logs
Static website logs do not trace App Service dependencies.
Trap 2: Azure Policy compliance scan
Policy evaluates resource compliance, not distributed application traces.
Trap 3: Cost Management budgets only
Budgets track spend but do not diagnose request paths.
- A
Application Insights with dependency tracking
Application Insights provides request, dependency, exception, and trace telemetry for application diagnostics.
- B
Storage account static website logs
Why wrong: Static website logs do not trace App Service dependencies.
- C
Azure Policy compliance scan
Why wrong: Policy evaluates resource compliance, not distributed application traces.
- D
Cost Management budgets only
Why wrong: Budgets track spend but do not diagnose request paths.
A Cosmos DB container for session records receives hot-partition throttling because the partition key has only five possible values. What should the developer change?
Trap 1: Increase the default TTL
TTL controls item expiry, not partition distribution.
Trap 2: Enable analytical store only
Analytical store supports analytics but does not correct transactional hot partitions.
Trap 3: Use a stored procedure for every write
Stored procedures do not fix a hot partition key.
- A
Increase the default TTL
Why wrong: TTL controls item expiry, not partition distribution.
- B
Enable analytical store only
Why wrong: Analytical store supports analytics but does not correct transactional hot partitions.
- C
Choose a partition key with higher cardinality and even request distribution
A good partition key spreads storage and throughput across logical partitions.
- D
Use a stored procedure for every write
Why wrong: Stored procedures do not fix a hot partition key.
An Azure App Service application has memory pressure. The developer needs distributed tracing across requests and dependencies. What should be enabled?
Trap 1: Azure Policy compliance scan
Policy evaluates resource compliance, not distributed application traces.
Trap 2: Cost Management budgets only
Budgets track spend but do not diagnose request paths.
Trap 3: Storage account static website logs
Static website logs do not trace App Service dependencies.
- A
Application Insights with dependency tracking
Application Insights provides request, dependency, exception, and trace telemetry for application diagnostics.
- B
Azure Policy compliance scan
Why wrong: Policy evaluates resource compliance, not distributed application traces.
- C
Cost Management budgets only
Why wrong: Budgets track spend but do not diagnose request paths.
- D
Storage account static website logs
Why wrong: Static website logs do not trace App Service dependencies.
You are building a serverless image-processing solution using Azure Functions. The function must automatically run whenever a new image is uploaded to a blob container and must scale out to handle high upload volumes. Which trigger and hosting plan should you use?
Trap 1: Timer trigger with Consumption plan
A timer trigger runs on a fixed schedule, not in response to blob uploads. It does not activate on new blobs.
Trap 2: HTTP trigger with Premium plan
An HTTP trigger requires an incoming HTTP request; it does not fire automatically on blob uploads. The Premium plan is not needed for scaling.
Trap 3: Queue trigger with App Service plan
A queue trigger processes messages from an Azure Storage Queue, not blob events. The App Service plan would be unnecessary for the stated requirement and requires manual scaling or always-on.
- A
Timer trigger with Consumption plan
Why wrong: A timer trigger runs on a fixed schedule, not in response to blob uploads. It does not activate on new blobs.
- B
Blob trigger with Consumption plan
The blob trigger runs when a new blob is created, and the Consumption plan automatically scales out to handle high volumes.
- C
HTTP trigger with Premium plan
Why wrong: An HTTP trigger requires an incoming HTTP request; it does not fire automatically on blob uploads. The Premium plan is not needed for scaling.
- D
Queue trigger with App Service plan
Why wrong: A queue trigger processes messages from an Azure Storage Queue, not blob events. The App Service plan would be unnecessary for the stated requirement and requires manual scaling or always-on.
You are developing a solution that stores large media files in Azure Blob Storage. Users access these files frequently for the first 30 days, then rarely afterwards. To optimize costs, you need to automatically move blobs to a cooler tier after 30 days of creation. Which Azure feature should you use?
Trap 1: Blob inventory
Incorrect. Blob inventory provides a report of blobs but does not automate tier changes.
Trap 2: Change feed
Incorrect. Change feed logs blob creation and modification events but does not manage tier transitions.
Trap 3: Immutable storage
Incorrect. Immutable storage prevents modification or deletion of blobs but does not handle tiering.
- A
Lifecycle management policies
Correct. Lifecycle management policies automate tier transitions based on age, optimizing cost.
- B
Blob inventory
Why wrong: Incorrect. Blob inventory provides a report of blobs but does not automate tier changes.
- C
Change feed
Why wrong: Incorrect. Change feed logs blob creation and modification events but does not manage tier transitions.
- D
Immutable storage
Why wrong: Incorrect. Immutable storage prevents modification or deletion of blobs but does not handle tiering.
You are monitoring an ASP.NET Core web API with Application Insights. You want to view the SQL queries being executed, including the command text and duration, in the Application Insights portal. Which actions must you take? (Select all that apply.) (Choose 2.)
Trap 1: Install the `Microsoft.ApplicationInsights.Profiler.AspNetCore`…
Profiler provides per-request traces and can show SQL queries, but it does not automatically collect the SQL command text. You still need to enable command text instrumentation.
Trap 2: Enable adaptive sampling to ensure all SQL queries are collected.
Adaptive sampling reduces the amount of telemetry to control costs; it does not enable SQL command text collection. In fact, it may drop some dependency data.
- A
Install the `Microsoft.ApplicationInsights.Profiler.AspNetCore` NuGet package.
Why wrong: Profiler provides per-request traces and can show SQL queries, but it does not automatically collect the SQL command text. You still need to enable command text instrumentation.
- B
Install the `Microsoft.ApplicationInsights.DependencyCollector` NuGet package.
This package collects dependency telemetry (including SQL). By default, it does not capture SQL command text; it must be enabled via configuration.
- C
Set `EnableSqlCommandTextInstrumentation` to `true` in the `DependencyTrackingTelemetryModule` configuration.
This setting explicitly tells the dependency collector to include the SQL command text in telemetry, making it visible in the portal under the 'Dependencies' blade.
- D
Enable adaptive sampling to ensure all SQL queries are collected.
Why wrong: Adaptive sampling reduces the amount of telemetry to control costs; it does not enable SQL command text collection. In fact, it may drop some dependency data.
You have a web application monitored by Application Insights. You want to receive an alert when the average server response time exceeds 2 seconds for a rolling 5-minute period. Which alert rule type should you create?
Trap 1: Log alert based on a Kusto query that measures average response…
Log alerts can work but are more complex to set up and incur higher latency and cost; metric alerts are simpler for standard metrics.
Trap 2: Smart Detection alert on response time degradation
Smart Detection detects anomalies, not fixed thresholds; it may not fire for a consistent 2-second threshold.
Trap 3: Availability test alert for HTTP response time
Availability tests monitor synthetic transactions, not real user requests; they are not designed for server response time from actual traffic.
- A
Application Insights metric alert on 'Server response time' with condition 'Greater than 2' and evaluation frequency 5 minutes
Metric alerts are designed for threshold-based monitoring; this configuration will fire if the 5-minute average exceeds 2 seconds.
- B
Log alert based on a Kusto query that measures average response time in 5-minute windows
Why wrong: Log alerts can work but are more complex to set up and incur higher latency and cost; metric alerts are simpler for standard metrics.
- C
Smart Detection alert on response time degradation
Why wrong: Smart Detection detects anomalies, not fixed thresholds; it may not fire for a consistent 2-second threshold.
- D
Availability test alert for HTTP response time
Why wrong: Availability tests monitor synthetic transactions, not real user requests; they are not designed for server response time from actual traffic.
An Azure Function processes events from Event Hubs. You need to monitor the number of events that were successfully processed and those that were dropped due to processing errors. Which approach should you use?
Trap 1: Event Hubs metrics.
Incorrect. Event Hubs metrics show incoming and outgoing events, not processing status.
Trap 2: Stream Analytics job.
Incorrect. Stream Analytics could transform data but is unnecessary for the stated requirement for monitoring function processing.
Trap 3: Log Analytics query on function logs.
Incorrect. While you can query logs, custom metrics are more efficient and structured for this purpose.
- A
Custom metrics in Application Insights.
Correct. You can use the Application Insights SDK to log custom events or metrics for processed and dropped events.
- B
Event Hubs metrics.
Why wrong: Incorrect. Event Hubs metrics show incoming and outgoing events, not processing status.
- C
Stream Analytics job.
Why wrong: Incorrect. Stream Analytics could transform data but is unnecessary for the stated requirement for monitoring function processing.
- D
Log Analytics query on function logs.
Why wrong: Incorrect. While you can query logs, custom metrics are more efficient and structured for this purpose.
You are monitoring a web application with Application Insights. The application occasionally returns HTTP 500 errors. You want to be notified immediately when the error rate exceeds 5% of all requests in a rolling 5-minute window. Which feature of Application Insights should you configure?
Trap 1: Create a Smart Detection rule for anomalous failures.
Smart Detection analyzes telemetry over time and raises alerts for anomalies, but it does not allow you to set a fixed threshold like 5%. It is AI-based and not configurable with specific percentages.
Trap 2: Create a metric alert on the 'Failed requests' metric with a…
Metric alerts work on single metrics (e.g., count of failed requests), not on a ratio. To monitor percentage of failed requests, you need a log alert that calculates the ratio.
Trap 3: Create an availability test that checks for HTTP 200 responses and…
Availability tests are for probing endpoints from external locations. They do not measure error rates within the application's traffic.
- A
Create a Smart Detection rule for anomalous failures.
Why wrong: Smart Detection analyzes telemetry over time and raises alerts for anomalies, but it does not allow you to set a fixed threshold like 5%. It is AI-based and not configurable with specific percentages.
- B
Create a metric alert on the 'Failed requests' metric with a threshold of 5%.
Why wrong: Metric alerts work on single metrics (e.g., count of failed requests), not on a ratio. To monitor percentage of failed requests, you need a log alert that calculates the ratio.
- C
Create a log alert using a Kusto query that calculates the percentage of failed requests over the last 5 minutes, with an alert condition when the result exceeds 0.05.
Log alerts allow complex queries. For example: 'requests | where timestamp > ago(5m) | summarize total=count(), failures=countif(success == false) | extend percent = failures * 100.0 / total | where percent > 5'. This triggers an alert when the condition is met.
- D
Create an availability test that checks for HTTP 200 responses and alert on failures.
Why wrong: Availability tests are for probing endpoints from external locations. They do not measure error rates within the application's traffic.
You need to diagnose a slow-performing Azure Function. Application Insights shows that the function's dependency calls to an external API take an unusually long time. Which Application Insights feature should you use to visualize the end-to-end request flow?
Trap 1: Metrics Explorer
Metrics Explorer is used for charting and querying metric data, but it does not show the end-to-end flow of a specific request.
Trap 2: Live Metrics Stream
Live Metrics Stream provides real-time monitoring but not a topological view of dependencies.
Trap 3: Smart Detection
Smart Detection automatically alerts on anomalies but does not provide an end-to-end visualization.
- A
Metrics Explorer
Why wrong: Metrics Explorer is used for charting and querying metric data, but it does not show the end-to-end flow of a specific request.
- B
Live Metrics Stream
Why wrong: Live Metrics Stream provides real-time monitoring but not a topological view of dependencies.
- C
Application Map
Application Map visualizes the call flow between components and highlights performance issues, including slow dependencies.
- D
Smart Detection
Why wrong: Smart Detection automatically alerts on anomalies but does not provide an end-to-end visualization.
You are implementing an Azure Durable Functions application that processes orders. The function must call three external APIs (payment gateway, inventory system, and shipping calculator) in parallel, then aggregate the results once all three have completed. Which Durable Functions pattern should you use?
Trap 1: Function chaining
Function chaining executes activities sequentially, not in parallel.
Trap 2: Monitor
Monitor pattern repeatedly checks an external state, not used for parallel execution.
Trap 3: Human interaction
Human interaction pattern waits for an external manual signal, not parallel API calls.
- A
Function chaining
Why wrong: Function chaining executes activities sequentially, not in parallel.
- B
Fan-out/Fan-in
Fan-out calls multiple activity functions in parallel, and fan-in waits for all to complete before aggregating results.
- C
Monitor
Why wrong: Monitor pattern repeatedly checks an external state, not used for parallel execution.
- D
Human interaction
Why wrong: Human interaction pattern waits for an external manual signal, not parallel API calls.
You are monitoring an Azure App Service using Application Insights. You notice that HTTP 500 errors are increasing, but the standard server response time metric remains normal. You suspect that the errors are occurring in an external API call made by the application. How can you identify the dependency that is failing?
Trap 1: Enable snapshot debugging for the application.
Snapshot debugger captures a snapshot of the application state on exceptions but does not show dependency-level failure rates across all requests.
Trap 2: Use Application Insights Profiler to capture code-level traces.
Profiler is for diagnosing performance bottlenecks in code, not for identifying external dependency failures.
Trap 3: Set up a custom event telemetry for each external call.
While possible, custom events require manual instrumentation and do not automatically provide the aggregated failure metrics that built-in dependency tracking does.
- A
Enable snapshot debugging for the application.
Why wrong: Snapshot debugger captures a snapshot of the application state on exceptions but does not show dependency-level failure rates across all requests.
- B
Use Application Insights Profiler to capture code-level traces.
Why wrong: Profiler is for diagnosing performance bottlenecks in code, not for identifying external dependency failures.
- C
Configure Application Insights dependency tracking and view the Dependency Metrics blade.
Dependency tracking records each call to external services, and the metrics blade aggregates failures and durations for each dependency, making it easy to spot failures.
- D
Set up a custom event telemetry for each external call.
Why wrong: While possible, custom events require manual instrumentation and do not automatically provide the aggregated failure metrics that built-in dependency tracking does.
You are monitoring an Azure Web App with Application Insights. You notice that certain requests have high server response times. You need to identify which specific database queries are causing the delays. Which Application Insights feature should you use?
Trap 1: Live Metrics Stream
Incorrect. Live Metrics Stream provides real-time performance counters but does not offer detailed per-query breakdowns.
Trap 2: Performance blade
Incorrect. The Performance blade shows aggregated metrics and top dependencies, but not the exact query-level timing for a specific request.
Trap 3: Application Map
Incorrect. Application Map visualizes system components and their interactions, but it does not show the duration of individual database queries.
- A
Application Insights Profiler
Correct. Profiler traces end-to-end requests, showing the duration of each dependency call, including database queries, at the individual query level.
- B
Live Metrics Stream
Why wrong: Incorrect. Live Metrics Stream provides real-time performance counters but does not offer detailed per-query breakdowns.
- C
Performance blade
Why wrong: Incorrect. The Performance blade shows aggregated metrics and top dependencies, but not the exact query-level timing for a specific request.
- D
Application Map
Why wrong: Incorrect. Application Map visualizes system components and their interactions, but it does not show the duration of individual database queries.
You are monitoring an Azure Web App with Application Insights. You notice that the dependency duration for a SQL database call has significantly increased. You need to identify the specific SQL query that is causing the slowness. Which Application Insights feature should you use?
Trap 1: Application Map
Application Map visualizes the flow and dependencies but does not show detailed query texts.
Trap 2: Live Metrics Stream
Live Metrics is for real-time monitoring and does not provide historical drill-down into specific queries.
Trap 3: Smart Detection
Smart Detection identifies anomalies and sends alerts but does not show the specific SQL query details.
- A
Application Map
Why wrong: Application Map visualizes the flow and dependencies but does not show detailed query texts.
- B
Performance blade and drill into Dependencies
The Performance blade shows dependency details including SQL query text, duration, and count, allowing you to identify slow queries.
- C
Live Metrics Stream
Why wrong: Live Metrics is for real-time monitoring and does not provide historical drill-down into specific queries.
- D
Smart Detection
Why wrong: Smart Detection identifies anomalies and sends alerts but does not show the specific SQL query details.
You are troubleshooting an Azure Function that intermittently throws exceptions. You have enabled Application Insights. You need to capture the exact line of code that caused the exception, even for exceptions that occur during high load. Which feature should you use?
Trap 1: Application Insights Profiler
Incorrect. Profiler traces performance of requests but does not capture exception context or source code lines for errors.
Trap 2: Live Metrics Stream
Incorrect. Live Metrics shows real-time performance data but does not capture detailed exception snapshots.
Trap 3: SQL Insights
Incorrect. SQL Insights is for monitoring database queries, not application exceptions.
- A
Snapshot Debugger
Correct. Snapshot Debugger automatically collects debug snapshots on exceptions, providing the call stack and local variables at the moment of failure.
- B
Application Insights Profiler
Why wrong: Incorrect. Profiler traces performance of requests but does not capture exception context or source code lines for errors.
- C
Live Metrics Stream
Why wrong: Incorrect. Live Metrics shows real-time performance data but does not capture detailed exception snapshots.
- D
SQL Insights
Why wrong: Incorrect. SQL Insights is for monitoring database queries, not application exceptions.
You are using Application Insights to monitor a web application. You need to create an alert that triggers when the server response time exceeds 5 seconds for more than 10% of requests in a 5-minute window. Which type of Azure Monitor alert should you create?
Trap 1: Metric alert
Metric alerts track pre-aggregated metrics like average server response time. They cannot easily compute a ratio of requests exceeding a threshold versus total requests.
Trap 2: Activity log alert
Activity log alerts trigger on resource-level events (e.g., creation, deletion) and are not suitable for performance metric thresholds.
Trap 3: Application Insights smart detection alert
Smart detection uses machine learning to detect anomalies automatically but does not allow custom threshold definition.
- A
Metric alert
Why wrong: Metric alerts track pre-aggregated metrics like average server response time. They cannot easily compute a ratio of requests exceeding a threshold versus total requests.
- B
Log alert
Log alerts run a Kusto query that can group and count requests, calculate the percentage with duration > 5000 ms of total requests, and trigger when that percentage exceeds 10 over the evaluation period.
- C
Activity log alert
Why wrong: Activity log alerts trigger on resource-level events (e.g., creation, deletion) and are not suitable for performance metric thresholds.
- D
Application Insights smart detection alert
Why wrong: Smart detection uses machine learning to detect anomalies automatically but does not allow custom threshold definition.
You deploy a web application to Azure App Service. You need to deploy a new version of the application without downtime and have the ability to test the new version before switching traffic. Which feature should you use?
Trap 1: Auto-scaling
Incorrect. Auto-scaling handles load changes by adjusting instance count, not application version deployment.
Trap 2: Backup
Incorrect. Backup saves your app's configuration and content, but does not help with deploying new versions without downtime.
Trap 3: Custom domains
Incorrect. Custom domains map a domain name to your app, but do not aid in deployment or testing new versions.
- A
Deployment slots
Correct. Deployment slots allow you to deploy to a staging environment and swap with production, enabling zero downtime and testing.
- B
Auto-scaling
Why wrong: Incorrect. Auto-scaling handles load changes by adjusting instance count, not application version deployment.
- C
Backup
Why wrong: Incorrect. Backup saves your app's configuration and content, but does not help with deploying new versions without downtime.
- D
Custom domains
Why wrong: Incorrect. Custom domains map a domain name to your app, but do not aid in deployment or testing new versions.
Question Discussion
Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.
Sign in to join the discussion.