mcAfee Secure Website
23

Microsoft AZ-104 Bundle

Exam Code: AZ-104

Exam Name Microsoft Azure Administrator

Certification Provider: Microsoft

Corresponding Certification: Microsoft Certified: Azure Administrator Associate

AZ-104 Training Materials $44.99

Reliable & Actual Study Materials for AZ-104 Exam Success

The Latest AZ-104 Exam Questions as Experienced in the Actual Test!

  • 24
    Questions & Answers

    AZ-104 Questions & Answers

    606 Questions & Answers

    Includes questions types found on actual exam such as drag and drop, simulation, type in, and fill in the blank.

  • 25
    AZ-104 Video Course

    AZ-104 Training Course

    132 Video Lectures

    Based on Real Life Scenarios which you will encounter in exam and learn by working with real equipment.

  • exam =30
    Study Guide

    AZ-104 Study Guide

    458 PDF Pages

    Study Guide developed by industry experts who have written exams in the past. They are technology-specific IT certification researchers with at least a decade of experience at Fortune 500 companies.

exam =32

Microsoft Azure Administrator (AZ-104) Practice Tests

Guarantee

Satisfaction Guaranteed

Pass4sure has a remarkable Microsoft Candidate Success record. We're confident of our products and provide no hassle product exchange. That's how confident we are!

99.3% Pass Rate
Total Cost: $194.97
Bundle Price: $149.98

Purchase Individually

  • exam =34
    Questions & Answers

    Questions & Answers

    606 Questions

    $124.99
    exam =35
  • exam =37
    AZ-104 Video Course

    Training Course

    132 Video Lectures

    $39.99
  • exam =36
    Study Guide

    Study Guide

    458 PDF Pages

    $29.99

Microsoft AZ-104 Practice Test 81

Question 800

A Log Analytics custom table `AppEvents_CL` records one row per request with datetime `TimeGenerated` and string `Result_s` equal to `Success` or `Failure`. A dashboard needs the count of failed requests in each 15-minute time bucket over the last six hours. Which complete KQL query returns that trend without counting successes?

  1. `AppEvents_CL | where TimeGenerated >= ago(6h) and Result_s == "Failure" | summarize FailureCount=count() by Result_s`
  2. `AppEvents_CL | where TimeGenerated >= ago(6h) and Result_s == "Failure" | summarize FailureCount=count() by bin(TimeGenerated, 15m)`
  3. `AppEvents_CL | summarize FailureCount=count() by bin(TimeGenerated, 15m)`
  4. `AppEvents_CL | where TimeGenerated >= ago(6h) | summarize FailureCount=count() by bin(TimeGenerated, 15m), Result_s`

Explanation

Correct Answer

B:

The `where` clause restricts both the six-hour time window and the failure status. `summarize count() by bin(TimeGenerated, 15m)` then rounds each event timestamp into a 15-minute bucket and reports only failure counts per bucket, exactly matching the dashboard requirement.

Incorrect Answers

A:

The predicates select recent failures, but grouping only by `Result_s` produces a single aggregate for the value Failure. It does not preserve the required series of 15-minute time bins.

C:

This query creates 15-minute buckets but omits the six-hour filter and includes both successes and failures. A valid time-bucket shape without the correct row predicates does not produce a failed-request trend.

D:

Grouping by status and time bucket produces separate Success and Failure rows, since the query lacks the required `Result_s == "Failure"` filter. The resulting data includes successful-request counts and therefore does not satisfy the requested failure-only output.

Question 801

A query is slow because it scans months of log data without filtering. Which Azure configuration or procedure is the best fit?

  1. Use KQL `summarize count() by bin(TimeGenerated, 15m)` with an appropriate where clause.
  2. Filter TimeGenerated and required resource identifiers early, then project needed fields.
  3. Filter only failure status while leaving the months-long TimeGenerated range unbounded.
  4. Filter only _ResourceId while leaving the months-long TimeGenerated range unbounded.

Explanation

Correct Answer

B:

Apply an early where filter on TimeGenerated to limit scanned extents, add the necessary resource/tenant predicates, then project the columns needed by later operators. This reduces the amount of data processed before joins or aggregations; check workspace indexing and the actual table schema instead of adding arbitrary computation first.

Incorrect Answers

A:

A 15-minute time bin is useful for summarizing an already filtered time series, but grouping does not itself prevent a query from reading months of underlying records. A restrictive where TimeGenerated filter should occur early before any expensive aggregation.

C:

A failed-sign-in filter is relevant only when investigating authentication failures in the sign-in table. The query described is slow because of excessive historical scans, so constraining the time range and relevant resource IDs is the generally necessary first optimization.

D:

Filtering by _ResourceId can reduce the number of resources represented, but if the query still ranges across months of logs, it may continue scanning far more time than the report needs. Combine resource scoping with a time predicate and minimal projected columns.

Question 802

A Log Analytics custom table `AppErrors_CL` contains one row per application failure, a datetime `TimeGenerated` and string `ErrorCode_s` (sometimes empty). The SOC needs the five nonblank error codes with the highest number of occurrences during the past 48 hours, sorted from most to least frequent. Which KQL query returns that ranking?

  1. AppErrors_CL | where TimeGenerated >= ago(48h) | top 5 by TimeGenerated desc | summarize FailureCount=count() by ErrorCode_s
  2. AppErrors_CL | where TimeGenerated >= ago(48h) and isnotempty(ErrorCode_s) | summarize FailureCount=count() by ErrorCode_s | top 5 by FailureCount desc
  3. AppErrors_CL | where TimeGenerated >= ago(48h) and isnotempty(ErrorCode_s) | summarize FailureCount=count() by bin(TimeGenerated, 1h) | top 5 by FailureCount desc
  4. AppErrors_CL | where TimeGenerated >= ago(48h) and isnotempty(ErrorCode_s) | distinct ErrorCode_s | top 5 by ErrorCode_s asc

Explanation

Correct Answer

B:

The 48-hour predicate restricts the event window, isnotempty removes missing codes, summarize count() by ErrorCode_s counts every occurrence per code, and top 5 by FailureCount desc returns the five largest counts. Microsoft documents summarize group aggregation and top sorting as separate operators, in this order.

Incorrect Answers

A:

Taking the five newest raw event rows before aggregation discards almost all of the 48-hour sample. A resulting count by ErrorCode_s ranks only that recent five-event subset, not the five codes with the most occurrences across the whole interval, and blank codes are not excluded.

C:

Grouping by hourly TimeGenerated bins counts failures per hour rather than per ErrorCode_s. Even if the five highest hourly counts are returned, they do not identify which error codes are the most frequent.

D:

Distinct removes duplicate code values before ordering and therefore throws away how often each code occurred. Alphabetical top results cannot establish the ranking by occurrence frequency required by the SOC.

Question 803

Log Analytics table `AppEvents_CL` has columns `TimeGenerated` and `Payload_s` (string). One `Payload_s` value is `{"http":{"status":503,"path":"/checkout"}}`. The application team must find only checkout events with HTTP status 500 or higher during the last hour using the nested JSON fields; ingestion transforms have not extracted those fields. Which KQL expression meets the requirement?

  1. `AppEvents_CL | where TimeGenerated >= ago(1h) | extend p=parse_json(Payload_s) | where toint(p.http.status)>=500 and tostring(p.http.path)=="/checkout"`
  2. `AppEvents_CL | where TimeGenerated >= ago(1h) and Payload_s.http.status >= 500` — access `http.status` directly on the string field without parsing.
  3. `AppEvents_CL | extend p=tostring(Payload_s) | where p.http.path=="/checkout"` — convert the JSON string to another string before accessing nested properties.
  4. `AppEvents_CL | summarize count() by Payload_s` — group by each complete unparsed payload and treat the group count as the status code.

Explanation

Correct Answer

A:

`parse_json` converts the JSON string into a dynamic property bag, so `p.http.status` and `p.http.path` can be addressed. Casting the nested values to numeric and string types makes the failure threshold and exact checkout-path comparison reliable after applying the one-hour time filter.

Incorrect Answers

B:

`Payload_s` is explicitly a string, not a dynamic object with an accessible `http` property. KQL must parse the JSON string or extract its fields before a nested numeric comparison; the dot path on the raw string does not implement the required filter.

C:

`tostring(Payload_s)` keeps the input as string data and does not materialize a dynamic `http` property bag. It also fails to impose the one-hour window and the status-code threshold, so the query cannot isolate the specified HTTP failures.

D:

Grouping by the whole raw JSON payload does not extract `http.status` or `http.path`, and the resulting `count()` represents duplicate payload frequency rather than an HTTP status code. It also does not constrain the time window or filter the checkout path.

Question 804

Several App Services send diagnostic logs into the same Log Analytics workspace. A query counts failed requests but the report must isolate failures from exactly the production app whose Azure resource ID is known. What KQL filtering strategy is most reliable?

  1. Sort all events by raw message length; the production app will be the shortest log record.
  2. Cast latency to a string and group by its first character instead of checking resource identity.
  3. Filter only on TimeGenerated and assume all records in the shared workspace belong to the requested app.
  4. Filter the relevant log table using its documented resource-identity column (such as `_ResourceId`) for the exact production resource ID, along with the time and failure predicates.

Explanation

Correct Answer

D:

The resource identifier and failure/time predicates constrain the query to the intended app, provided the table schema supports that identity column.

Incorrect Answers

A:

Raw message length is unrelated to the Azure resource responsible for generating the telemetry in the shared workspace.

B:

Latency type casting cannot separate otherwise indistinguishable application identities and does not answer which resource failed.

C:

Time filters restrict event age but not the resource; they would still include failures from the other App Services.

Question 805

The Azure Monitor Transactions metric for a storage account reports failed Blob requests. The account has a diagnostic setting that sends Blob resource logs to workspace `law-store` using the resource-specific table mode. A KQL query against `AzureDiagnostics` for the same account and hour returns zero rows. No resource-log ingestion health check has yet been performed. What should the administrator validate first?

  1. Conclude that the platform Transactions metric is false because the AzureDiagnostics table has no rows, and delete the metric alert.
  2. Increase the storage account performance tier to force diagnostic events into AzureDiagnostics rather than the configured resource-specific tables.
  3. Check the diagnostic setting's selected Blob log categories and workspace destination, query the actual resource-specific table such as `StorageBlobLogs`, and allow for ingestion and time-range differences before concluding that events are missing.
  4. Join AzureDiagnostics to an unrelated VM Heartbeat table on computer name, assuming an unconfigured join can create missing Blob resource-log records.

Explanation

Correct Answer

C:

Azure Monitor supports both AzureDiagnostics mode and resource-specific tables for resource logs. Validate that the relevant categories are streaming to the intended workspace, query the correct table/ResourceId/time range and account for ingestion delay before diagnosing absent logs.

Incorrect Answers

A:

Platform metrics and resource logs use distinct collection pipelines and can have different availability. An empty query against a mismatched table does not refute a measured Transactions metric spike.

B:

Storage account pricing/performance configuration doesn't change the resource-specific versus AzureDiagnostics table selection made by Azure Monitor diagnostic settings. A tier change won't repair a query against the wrong table.

D:

A join can combine existing rows from correctly sourced tables, but it cannot synthesize storage events that were never queried from the right log table or sent to the workspace. A VM computer name isn't the necessary storage request identity.

Question 806

Two custom Azure Monitor Log Analytics tables are populated: `ApiRequests_CL(OperationId_s, TimeGenerated, DurationMs_d)` and `ApiErrors_CL(OperationId_s, TimeGenerated, ErrorCode_s)`. During the last 24 hours, an SRE needs the duration of EVERY request that has a matching error record and its error code. An operation can have multiple matching error events; do not arbitrarily deduplicate those matches. Which KQL approach is appropriate?

  1. Filter each table to the last 24 hours and use `join kind=inner` on the shared `OperationId_s`, then project the matching request duration and error code.
  2. Use `union ApiRequests_CL, ApiErrors_CL | summarize count() by bin(TimeGenerated, 1h)`; time buckets automatically correlate each request to its exact error event.
  3. Apply `summarize arg_max(TimeGenerated, *) by OperationId_s` to the requests alone, then infer the error code from `DurationMs_d`.
  4. Use a `leftanti` join on `OperationId_s` to return the requests without any corresponding error event; these are the failed operations.

Explanation

Correct Answer

A:

Filtering each table independently limits the search to the requested day. `join kind=inner` matches equal operation identifiers and returns the columns from both tables for every matching request/error combination, including multiple errors per operation without the default `innerunique` left-side deduplication.

Incorrect Answers

B:

`union` stacks request and error rows, and grouping their timestamps into hour buckets cannot establish an operation-identifier match. Multiple unrelated operations share the same hour, and the result does not combine duration with its corresponding error code.

C:

`arg_max` selects a latest row in one table, not a relational match with the error table. Request duration does not encode an error code, and collapsing to one row per operation could discard the multiple matching error events the question explicitly retains.

D:

A `leftanti` join is specifically for left-side rows with NO right-side key match. It would return requests without error records, the opposite of the requirement to display requests that do have matched errors and their error codes.

Question 807

A Log Analytics custom table stores request latency in a `DurationMs` column whose schema is string; representative values are `125.5` and `250`. The query `MyRequests_CL | summarize avg(DurationMs)` fails because the aggregate expects a numeric expression. Which correction calculates average latency?

  1. Use `summarize count() by bin(TimeGenerated, 15m)` without converting DurationMs.
  2. Sort `DurationMs` lexicographically and take the middle string as the arithmetic mean.
  3. Filter on `_ResourceId` only; the metric automatically becomes numeric after a resource filter is applied.
  4. Convert the string values with `todouble(DurationMs)` in the aggregation, handling null or unparsable entries as appropriate.

Explanation

Correct Answer

D:

KQL avg calculates the arithmetic mean of numeric expressions in a summarize operation. When a custom log has its duration stored as text, use a numeric conversion such as `summarize AverageMs = avg(todouble(DurationMs))`. This gives the aggregate numeric values and yields a mean across successfully converted records; malformed strings can become null and should be inspected separately. Changing time grouping, sort order or resource filtering alone cannot repair the string-to-number mismatch.

Incorrect Answers

A:

The count aggregation reports the number of records in each time bucket, not their average latency. Even with a useful time filter, it never evaluates numeric request durations. It may help analyze request volume, but the stated failure concerns the data type of a latency column.

B:

String ordering is lexical, so values such as 100 and 20 do not sort according to their numeric magnitude. Selecting a middle string would at best approximate a median under the wrong ordering, not an arithmetic mean. It cannot repair the numeric-type requirement of avg.

C:

Filtering by resource can limit which records contribute to a query, but a filter does not change the data type declared for DurationMs. Kusto will still receive a string expression when avg is evaluated. Type conversion must occur before or inside the aggregate.

Question 808

VM vm-orders exports the platform Percentage CPU metric to Azure Monitor, but the team does not collect guest performance counters in a Log Analytics workspace. It needs an email when average CPU stays above 85% for five minutes, without deploying new collection agents. Which TWO configurations meet that requirement? Select TWO answers.

  1. Attach an action group containing the approved email receiver to the VM metric alert.
  2. Create an alert processing rule that suppresses all alert notifications during business hours.
  3. Create a metric alert for vm-orders Percentage CPU with the requested threshold and evaluation window.
  4. Create a KQL log alert against a guest performance counter table that has never been ingested.
  5. Configure an email action group but do not associate it with any alert rule.

Explanation

Correct Answers

A:

An Azure Monitor action group defines the notification channel and recipients invoked when a matching alert fires. Associating an email-enabled action group with the metric alert gives operators the requested message without writing a custom script or deploying a data-collection agent. The action group does not evaluate CPU by itself; it must be attached to the separately configured rule so the notification corresponds to the required sustained threshold.

C:

Platform Percentage CPU is available as an Azure Monitor metric, so a metric alert can evaluate vm-orders directly using the specified 85-percent threshold, aggregation and five-minute period. The resulting alert represents sustained utilization without requiring guest performance-counter ingestion. Combine the metric condition with an email action group. A stand-alone action group cannot tell when CPU crosses the target; conversely, a metric alert without a suitable action may fire but send no email.

Incorrect Answers

B:

Alert processing rules can suppress or modify alert notifications, but broad suppression during business hours conflicts with emailing whenever the specified CPU threshold persists. The requirement contains no quiet-hours exception. A suppression schedule may be useful for maintenance windows in other cases, but it is not one of the two necessary alert-and-email configurations here.

D:

A scheduled-query alert depends on relevant performance records being ingested into a Log Analytics table. The stem explicitly states that guest counter collection has not been configured, so this proposed query has no such dataset to evaluate. Adding data collection would also conflict with the requirement to avoid new agents; the platform metric alert uses an available signal instead.

E:

The action group contains recipients and delivery settings, but no performance threshold or target VM. Leaving it unattached to an alert rule means no automatic CPU-based trigger invokes the email action. To meet the request, create both a CPU metric alert condition and an action group association. Merely saving recipient information has no effect on monitored CPU behavior.

Question 809

An existing Azure Monitor critical alert must automatically create a ticket in an ITSM platform that accepts authenticated API requests. Which action-group configuration provides that integration without depending on a legacy ITSM-specific connector?

  1. Create a metric alert rule and attach an email action group.
  2. Create a scheduled query/log alert using KQL results and an action group.
  3. Tune grouping/alert processing/rule conditions rather than send unrelated duplicate email actions.
  4. Attach an action group with a Logic App or secure webhook that calls the incident system API.

Explanation

Correct Answer

D:

An Azure Monitor action group can invoke a Logic App or an authenticated secure webhook when the critical alert fires. Configure the workflow or receiver to transform the common alert schema and create the incident through the ITSM API; test authentication and ticket creation end to end.

Incorrect Answers

A:

An email action group notifies people, but sending a message does not call the incident system API or guarantee a ticket. The existing alert already detects the critical condition; the missing step is incident-creation automation.

B:

A scheduled query alert uses KQL results to detect a condition in Log Analytics. Creating a second alert rule would not by itself call the ITSM API for the existing critical alert.

C:

Changing alert grouping or processing can modify notification behavior, but it does not construct and authenticate the ticket-creation API request. That is performed by the action-group automation receiver and its workflow.

Question 810

An Azure Monitor metric alert covers CPU utilization for twelve application VMs in one resource group. Only vm-app03 is undergoing approved patching tonight from 22:00 to 23:00. Operations must silence notifications for that VM during this hour but continue evaluating the alert and notifying on failures from the other eleven VMs. What should be configured?

  1. Disable the shared metric alert rule for the hour and re-enable it after patching.
  2. Remove the email action group from the shared metric alert rule for all VMs during patching.
  3. Change the CPU threshold to 100% for every VM so alert notifications are unlikely during maintenance.
  4. Create a scheduled alert processing rule scoped or filtered to vm-app03 that suppresses notifications during the maintenance interval.

Explanation

Correct Answer

D:

Azure Monitor alert processing rules can apply a Suppress notifications action to matching alerts and can be scheduled for a maintenance window. Scope or filter the rule to vm-app03 and set the 22:00–23:00 interval. The metric alert can still fire and record alert instances for all VMs; notifications for unaffected targets remain available.

Incorrect Answers

A:

Disabling the shared rule would stop alert evaluation for all twelve VMs. Operations explicitly needs unaffected VMs monitored and notified throughout the patch, so turning off the common alert rule is too broad.

B:

Changing the shared action group would remove notifications for production VMs that are not under maintenance. An alert processing rule can suppress actions for just the target resource without changing the shared rule’s normal routing.

C:

Changing the CPU threshold for all VMs weakens detection and still does not implement the narrow one-hour maintenance exception. Monitoring thresholds and action-group notification handling are separate controls.