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 44

Question 430

A deployment named `app-prod-081` has succeeded in resource group `rg-apps`. Its Bicep file declares `output endpointUrl string = web.properties.defaultHostName`. A downstream CI/CD stage needs that exact endpoint value, but it is not automatically available as an environment variable. Which step retrieves the declared result reliably for the downstream stage?

  1. Read only the resource-group tags, because Bicep output variables are automatically copied to `rg-apps.tags`.
  2. List all Azure VM network interfaces in the subscription and assume one contains the web app deployment output.
  3. Query `az deployment sub show` without a subscription-level deployment name, because a successful group deployment is always stored at subscription scope.
  4. Retrieve the named group deployment using `az deployment group show -g rg-apps -n app-prod-081 --query properties.outputs.endpointUrl.value`, and pass that value explicitly into the next pipeline stage.

Explanation

Correct Answer

D:

Deployment outputs are stored under `properties.outputs`, with each named output's result in its `value` member. Querying the specific successful group deployment returns endpointUrl; the pipeline must then explicitly map that value for the later stage.

Incorrect Answers

A:

Bicep output declarations produce deployment results; they are not automatically materialized as resource-group tags. Unless the template explicitly writes a tag, reading rg-apps tags does not retrieve endpointUrl.

B:

A web app default hostname is a Microsoft.Web site property exposed through the deployment output, not a VM NIC inventory field. Listing unrelated VM adapters cannot reliably supply that declared Bicep result.

C:

The execution was a resource-group deployment, and its output belongs to that named group deployment's record. A subscription deployment lookup is the wrong scope and lacks the stated resource-group deployment identity.

Question 431

A resource-group deployment using Bicep incremental mode creates an Azure Key Vault and then reports `AuthorizationFailed` when it attempts to create a Storage account. Deployment operations show the storage write action is missing from the deployment identity. The Key Vault is healthy and contains data, and deleting it is prohibited. What is the safest next action?

  1. Inspect the failed deployment operation, grant the narrowly required storage-create authorization at the correct scope, and rerun the corrected incremental deployment without deleting the healthy Key Vault.
  2. Delete the entire resource group and rerun the template to avoid investigating the original Storage authorization failure.
  3. Change the deployment to complete mode to force-delete every resource absent from the template, including possible healthy assets.
  4. Move the same template to a management-group deployment without granting the missing Storage account write permission.

Explanation

Correct Answer

A:

The deployment operation error identifies a missing resource authorization. Correcting that permission and rerunning an idempotent incremental deployment allows ARM to reconcile target state while preserving the previously created Key Vault.

Incorrect Answers

B:

Deleting the resource group would destroy the healthy, data-bearing vault and is not necessary to resolve a permission-denied operation.

C:

Complete-mode deletion semantics introduce additional risk and do not grant the identity permission to create the Storage account, which is the observed failure.

D:

Changing management scope does not confer the missing `Microsoft.Storage/storageAccounts/write` permission and does not fix the Azure Resource Manager operation error.

Question 432

An admin wants a starting ARM template for a deployed VM. What should the administrator do to resolve this specific case?

  1. Parameterize/remove environment-specific values before source control or redeploy.
  2. Remove/rework unsupported exported properties following provider docs and validation failures.
  3. Consult provider schema and supply omitted settings rather than assume export is a complete backup.
  4. Export a supported deployment/resource template and review it for completeness before reuse.

Explanation

Correct Answer

D:

Exporting a template from the deployed VM or its resource group provides a starting declarative description of available resource settings. Generated exports can omit secrets or include environment-specific IDs, so review and parameterize the template before treating it as portable source.

Incorrect Answers

A:

Removing hard-coded environment values aids portability; it does not fix a failing export or provider-specific property definition on its own.

B:

Unsupported properties in an exported template should indeed be repaired if validation reports those errors, but the question asks for the starting template itself, not for remediation of an already failed redeployment. Export a supported template from the VM/deployment first; then inspect and correct unsupported or incomplete resource definitions before reuse.

C:

Consulting the schema can reveal omitted exported properties; it does not automatically recreate the Bicep source or adjust target resources.

Question 433

A team must convert existing ARM JSON into readable Bicep. Which change addresses the stated situation most precisely?

  1. Use `az bicep decompile` then inspect warnings and generated semantics manually.
  2. Refactor modules/parameters only after confirming equivalent output resource IDs and dependencies.
  3. Use the Bicep build/compiler rather than manually rename the .bicep extension.
  4. Rebuild and test declarative Bicep source instead of relying on one portal-generated export.

Explanation

Correct Answer

A:

`az bicep decompile` translates supported ARM JSON constructs into editable Bicep source. Decompilation can emit warnings or require manual fixes, so validate the resulting resource types, references and deployment semantics before use.

Incorrect Answers

B:

Refactoring modules preserves code structure and dependencies; it is not the direct operation for an invalid template output or source conversion.

C:

The Bicep compiler generates an ARM template from Bicep; renaming extensions does not convert the source language or perform a deployment.

D:

Rebuilding all Bicep by hand from a portal export can be a later maintainability exercise, but the immediate transformation requested is from existing ARM JSON syntax. Use `az bicep decompile` as the conversion starting point, examine warnings and generated expressions, then test the resulting semantics before using it as authoritative infrastructure code.

Question 434

An exported ARM template contains hard-coded resource names and secrets. What is the most appropriate next administrative decision?

  1. Use the Bicep build/compiler rather than manually rename the .bicep extension.
  2. Parameterize/remove environment-specific values before source control or redeploy.
  3. Rebuild and test declarative Bicep source instead of relying on one portal-generated export.
  4. Export a supported deployment/resource template and review it for completeness before reuse.

Explanation

Correct Answer

B:

A portal-exported ARM template can contain hard-coded location, resource IDs, environment-specific names and occasionally sensitive configuration values. Replace those values with appropriate parameters or references, exclude credentials from source control and use secure deployment inputs. Validate and test the resulting template before treating it as a reusable infrastructure definition.

Incorrect Answers

A:

`bicep build` compiles Bicep to ARM JSON; the input in this case is already ARM JSON and still contains hardcoded environment identifiers and sensitive values. Compilation is not a substitute for extracting secrets and parameterizing the source.

C:

Rearchitecting infrastructure into a new declarative Bicep source may be desirable later, but it does not immediately make committed exported JSON safe. Hard-coded resource identifiers and secrets must first be removed or parameterized, with sensitive settings handled through secure mechanisms, before source control or redeployment.

D:

Exporting a deployment is a starting point for review, not a guarantee of parameterized or complete reusable source and not a source-code compiler.

Question 435

A portal-exported ARM template for a running App Service omits some settings configured after its deployment. A new environment needs those settings reproduced. What is the safe IaC remediation?

  1. Compare the live resource against provider resource schema and export, then explicitly add missing supported settings to the validated template.
  2. Assume the portal export includes all present-day settings and deploy it unreviewed.
  3. Give the deployment identity Global Administrator and ignore missing exported properties.
  4. Delete the existing app so exported values become complete automatically.

Explanation

Correct Answer

A:

Portal-exported templates can be incomplete for current live configuration; use supported resource schema and actual settings to fill the gaps before deployment.

Incorrect Answers

B:

A resource export is not a guaranteed complete backup of every current provider-specific setting, so blind reuse risks configuration drift.

C:

Directory Global Administrator is excessive and unrelated to omitted properties in the ARM export payload.

D:

Deleting the running app neither repairs template omissions nor protects production configuration and data.

Question 436

An existing ARM JSON template contains a resource declaration whose old API version does not support a required current resource property, so template deployment fails API-version validation. The team wants to keep the ARM JSON format. Which corrective action addresses the failure directly?

  1. Update the resource declaration to a supported provider API version and property schema, then validate the ARM template and examine a deployment what-if.
  2. Use `az bicep decompile` then inspect warnings and generated semantics manually.
  3. Compare exported source with actual resource settings and use what-if in target scope.
  4. Refactor modules/parameters only after confirming equivalent output resource IDs and dependencies.

Explanation

Correct Answer

A:

A resource provider exposes version-specific properties and accepted API versions. Correct the ARM resource apiVersion and the property shape using the provider documentation, then validate and inspect a what-if before deploying; no conversion to Bicep is required.

Incorrect Answers

B:

The Bicep decompile operation is intended to convert ARM JSON into Bicep source. This project is explicitly keeping ARM JSON, and decompilation alone does not establish a provider-supported resource API version or property schema.

C:

Comparing export and current deployment can help identify drift, but by itself does not update the invalid apiVersion and unsupported property shape in the declared ARM resource.

D:

Changing module organization or parameter layout can improve maintainability but does not resolve the resource provider rejecting an unsupported API version for this resource type.

Question 437

An App Service and its storage account were originally deployed with ARM JSON in 2024. Since then administrators have changed supported configuration properties directly in Azure portal. The original parameterized deployment history template is still available, but an audit specifically needs an initial export that reflects the CURRENT resource settings—including those later manual changes—before engineers hand-review, parameterize and validate it as possible infrastructure-as-code. Which source should be exported first?

  1. Export an autogenerated template from the current selected resources or their resource group, then manually inspect it for missing/unsupported properties before treating it as a starting snapshot.
  2. Select Save from history for the 2024 deployment and assume its original ARM JSON contains every manual portal change made after that deployment.
  3. Decompile the 2024 deployment-history JSON with `az bicep decompile` without re-reading live resources; converting the file automatically merges all later portal changes.
  4. Only run what-if against the old 2024 template and use its proposed changes as an exact, complete current-resource template export without capturing live resources.

Explanation

Correct Answer

A:

Microsoft distinguishes resource or resource-group export, which generates a snapshot of supported CURRENT resource state including later manual changes, from Save from history, which retrieves the template as originally deployed. The snapshot is the correct starting evidence for this request. Exports can be incomplete or contain unsupported or hard-coded properties, so manual verification and parameterization are still mandatory before production reuse.

Incorrect Answers

B:

Deployment history Save from history returns an exact copy of the template used for that deployment—not a live-state snapshot. The 2024 file can be useful for auditing original intent or as a reusable parameterized baseline, but any later out-of-band portal modifications are absent, directly violating the stated current-state evidence requirement.

C:

Bicep decompilation converts ARM JSON syntax into a best-effort Bicep representation of the JSON supplied. It has no automatic read or merge of present-day live resource configuration, and Microsoft cautions that decompilation may need manual repairs. Converting an old template without inspecting current resources cannot reveal portal changes made years later.

D:

What-if predicts differences between a proposed template and Azure current state; it does not export the existing resources as a complete declarative template. Against the old 2024 template it can show potential changes or deletions but cannot itself supply an editable current-state starting export. Use current-resource export plus audit, then what-if later as a separate validation step.

Question 438

Before promoting an updated ARM template for a billing application, a release engineer needs two distinct kinds of evidence: whether the checked-in declarations reflect the current Azure resource settings, and what create/update/delete operations the modified template would attempt on the target group. Which TWO checks provide that evidence? Select TWO answers.

  1. Run Azure Resource Manager what-if at the actual deployment scope to preview proposed resource changes.
  2. Compare the checked-in ARM declarations with an authorized export or inspection of the currently deployed resource configuration.
  3. Delete the entire target resource group and recreate it so current-state comparisons are unnecessary.
  4. Enable complete deployment mode in production without reviewing resources that might be removed.
  5. Rely on a successful JSON parse alone to prove the template will not change any existing resource.

Explanation

Correct Answers

A:

ARM what-if evaluates the deployment plan against existing resources at the target scope and reports expected changes, including creates, modifications and deletions. That is the right dry-run evidence for the second requirement; parsing the template alone cannot provide an impact preview. Review provider limitations and the output carefully, then verify intended differences before authorizing production deployment. What-if is not a substitute for checking whether source declarations accurately represent the current deployed configuration.

B:

A source-to-deployed-state comparison exposes drift: configuration may have changed directly in Azure since the repository template was last maintained. Inspect or export the relevant existing resources and compare their effective properties with the checked-in declarations, while filtering read-only/provider-generated fields from the comparison. That answers the first evidence requirement and helps decide which differences are intentional. It complements the what-if preview; merely knowing current state does not independently show the future deployment operations.

Incorrect Answers

C:

Deleting the entire resource group would destroy unrelated resources and their state, which is especially dangerous for a production billing application. It avoids neither drift analysis nor deployment-impact review, and it creates unnecessary downtime and recovery risk. Use non-destructive inspection and what-if to understand the changes before deploying.

D:

Complete deployment mode can remove resources omitted from the template, making an unreviewed production run hazardous. The request requires advance evidence of intended changes, not an execution mode that suppresses deliberation. Review the desired scope and what-if output before selecting an appropriate deployment approach.

E:

A syntactically valid template may still change or delete resources when applied. JSON parsing does not evaluate live Azure state, provider behavior, resource dependencies or deployment mode effects. It cannot answer either requested evidence question. The engineer needs current-configuration comparison plus a scope-specific what-if plan.

Question 439

An exported template includes unsupported extensions. What is the most appropriate next administrative decision?

  1. Export a supported deployment/resource template and review it for completeness before reuse.
  2. Compare exported source with actual resource settings and use what-if in target scope.
  3. Consult provider schema and supply omitted settings rather than assume export is a complete backup.
  4. Remove/rework unsupported exported properties following provider docs and validation failures.

Explanation

Correct Answer

D:

Resource provider schemas define valid resource properties for each API version. If an exported template contains properties or extension resources that no longer validate, identify the incompatible declarations and remodel or remove them using supported schema. Re-run validation and what-if against the intended environment rather than assuming exports are always redeployable.

Incorrect Answers

A:

Exporting another deployment template is useful for obtaining a starting definition, but does not in itself remove properties or extension resources that current provider schema rejects. Once export-validation failures identify unsupported content, edit or remodel the problematic declarations to supported API versions and properties and rerun validation.

B:

Comparing exports with live settings finds drift and omissions, not an automatic solution to the source authoring or deployment operation in question.

C:

Provider documentation and schemas can explain which properties are supported, but the exported template has extensions rejected by validation. The administrator must actually remove or remodel those unsupported properties before a reliable deployment.

Question 440

A generated Bicep file contains verbose nested JSON expressions. Which administrative action most directly meets the requirement?

  1. Modernize resource API versions carefully after decompile and regression testing.
  2. Refactor modules/parameters only after confirming equivalent output resource IDs and dependencies.
  3. Use `az bicep decompile` then inspect warnings and generated semantics manually.
  4. Export a supported deployment/resource template and review it for completeness before reuse.

Explanation

Correct Answer

B:

Generated Bicep and decompiled JSON expressions can contain redundant nested constructs and implicit dependencies. Refactor into modules and parameters only after preserving resource IDs, conditions, outputs and dependency order; use compile and what-if checks before replacing working infrastructure.

Incorrect Answers

A:

Changing API versions is a compatibility maintenance task; it does not replace needed conversion, parameter or source control workflow.

C:

Decompilation has already happened if the generated Bicep contains verbose nested JSON expressions. Running the same conversion again is not a substitute for reviewing and refactoring the generated source. Simplify expressions/modules after checking that resource IDs, parameter behavior, outputs and dependencies remain equivalent.

D:

Exporting an existing deployment may supply a baseline but it does not improve the verbose, generated Bicep already in hand. The refactor should preserve output resource IDs and dependencies while introducing maintainable modules or parameters.