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 42

Question 410

A Bicep file hardcodes a storage name and conflicts across environments. Which administrative action most directly meets the requirement?

  1. Define a shared tags object or parameter and reference it in each resource declaration.
  2. Parameterize the prefix and use supported uniqueString input for a deterministic unique name.
  3. Use a supported @allowed decorator or union type and validate supplied input.
  4. Use a loop with unique names and conditional constraints rather than copy-pasted blocks.

Explanation

Correct Answer

B:

Azure Storage account names must be globally unique and obey naming rules. A Bicep prefix parameter lets each deployment supply its environment value, while uniqueString on stable scope inputs creates a reproducible suffix; hardcoding one account name would collide across deployments.

Incorrect Answers

A:

A shared tags object centralizes resource labels but cannot substitute for the deployment logic, type constraint or scoped reference this case needs.

C:

A Bicep `@allowed` decorator or string-literal union constrains what values a parameter may accept. It doesn't stop a storage account's globally unique name from colliding across deployments. Make the account name depend on appropriate deployment-specific values and check the storage naming rules; restricting unrelated environment labels does not create uniqueness.

D:

A resource loop generates multiple declarations; it does not by itself establish the parameter, conditional or scoped behavior required here.

Question 411

A parent Bicep needs a reusable child network deployment. Which Azure configuration or procedure is the best fit?

  1. Move the network definition into a module with explicit parameters and outputs.
  2. Use symbolic property references when appropriate and remove unnecessary manual dependency.
  3. Use a supported @allowed decorator or union type and validate supplied input.
  4. Use @secure parameters and prevent sensitive values from appearing in outputs.

Explanation

Correct Answer

A:

A Bicep module encapsulates the network resources in a separately maintained file. The parent passes network settings as parameters and consumes declared outputs, so the module can be reused without duplicating the virtual-network resource declarations.

Incorrect Answers

B:

Symbolic Bicep property references produce implicit deployment dependencies and can remove redundant `dependsOn` entries. They do not package a child network deployment into a reusable unit with an independent parameter contract. A Bicep module is the appropriate construct for reusable network resources with explicit inputs and outputs.

C:

An @allowed list constrains valid input values; it does not create or secure the particular resource or condition demanded here.

D:

Secure parameters protect sensitive deployment inputs and redact outputs; they do not solve non-secret deployment shape or naming requirements.

Question 412

A Bicep string parameter must be constrained to allowed environment names. What should the administrator do to resolve this specific case?

  1. Use a loop with unique names and conditional constraints rather than copy-pasted blocks.
  2. Use a supported @allowed decorator or union type and validate supplied input.
  3. Parameterize the prefix and use supported uniqueString input for a deterministic unique name.
  4. Update the resource type version and property shape based on provider documentation.

Explanation

Correct Answer

B:

The `@allowed` decorator on a Bicep parameter, or a parameter union of permitted literals, restricts accepted environment values during template validation. Values outside that set are rejected instead of silently creating an unintended environment.

Incorrect Answers

A:

Bicep loops generate multiple resource or module instances, and naming expressions can differentiate those instances. The task is to constrain a single string parameter to approved environment values, not create repeated resources. Parameter validation with `@allowed` or a supported literal union addresses that requirement directly.

C:

uniqueString can form a repeatable name suffix; it does not repair the provider reference, target scope or required resource lifecycle.

D:

Changing a Microsoft resource provider API version changes which resource properties can be supplied in a resource declaration. It cannot restrict values accepted by a Bicep string parameter. Use the supported parameter `@allowed` decorator or a union of literal values for the allowed environment names; changing API versions is irrelevant to input validation.

Question 413

A team deploys the same Bicep file to `dev`, `test`, and `prod`. A `Microsoft.Storage/storageAccounts` resource named `auditStore` must be created only when parameter `environment` equals `prod`; it must not be created at all in `dev` or `test`. The rest of the file must deploy in every environment. Which Bicep change directly implements this requirement?

  1. Add `@allowed(['dev', 'test', 'prod'])` to `environment` but keep the `auditStore` resource declaration unconditional.
  2. Add an explicit `dependsOn` entry for `auditStore` so the resource is skipped whenever the environment is not production.
  3. Pass a different resource name from each environment parameter file while leaving the storage account declaration unconditional.
  4. Declare `auditStore` using `= if (environment == 'prod') { ... }`, with its normal storage-account properties in the conditional resource block.

Explanation

Correct Answer

D:

Bicep supports an `if` expression on a resource declaration. The condition evaluates `environment == 'prod'`, so the storage account is created only in production while unrelated resources remain unconditional. A false condition skips this declaration; any separately declared child resources or unsafe references must be handled consistently.

Incorrect Answers

A:

The `@allowed` decorator constrains accepted parameter values but does not conditionally exclude any resource from a deployment. An unconditional `auditStore` declaration is still deployed for `dev` and `test`, violating the requirement.

B:

The `dependsOn` property establishes ordering or prerequisites among resources; it is not a Boolean deployment condition. A dependency by itself cannot suppress creation of `auditStore` in non-production environments.

C:

Parameterizing a name changes the resource identity but still attempts to create a storage account in every environment. The scenario requires the entire resource to be omitted outside production rather than named differently.

Question 414

A secret is passed to a Bicep module and must avoid exposure. What is the most appropriate next administrative decision?

  1. Declare it with the `existing` keyword and correct scope, rather than create it twice.
  2. Use an `if` conditional expression on the Bicep declaration rather than comment out its resource.
  3. Use @secure parameters and prevent sensitive values from appearing in outputs.
  4. Move the network definition into a module with explicit parameters and outputs.

Explanation

Correct Answer

C:

Bicep supports the `@secure()` decorator for secret string or object parameters. Using it on the module's relevant parameter prevents the parameter value being stored in deployment history. Do not output the secret or pass it into nonsecure module parameters, because outputs and insecure downstream parameters can expose sensitive material.

Incorrect Answers

A:

The existing keyword tells Bicep to refer to a deployed resource; it will not build or reconfigure the resource if a new deployment action is required.

B:

An `if` on a Bicep resource or module controls conditional deployment. It does not protect the secret value passed to a module or prevent that value from being exposed in the deployment record or outputs. Use secure input parameters and avoid writing secrets to outputs or deployment logs.

D:

Moving a network into a module helps reuse declarations; it does not alone set the values, scope or permissions for the problem described.

Question 415

A Bicep template deploys into resource group rg-app, and the VNet vnet-shared already exists in the same resource group. The template needs to obtain this VNet resource ID without creating or updating a second VNet. What declaration is appropriate?

  1. Declare vnet-shared as a new resource with a different API version and rely on Azure to ignore duplicate creation.
  2. Declare a new VNet with the same name in a second resource group and use its ID instead.
  3. Read the existing VNet only from a local string variable without a resource reference, and assume Azure validates it automatically.
  4. Declare the VNet resource with the Bicep `existing` keyword and its name in the current resource-group scope, then reference its symbolic ID.

Explanation

Correct Answer

D:

The `existing` modifier binds the symbolic name to the existing resource without redeploying it. For a resource in the current deployment scope, name and type are sufficient.

Incorrect Answers

A:

A normal new-resource declaration participates in deployment and can cause changes to the resource. It is not a read-only existing-resource reference.

B:

Provisioning a second VNet produces a different resource and is not required to reference the existing rg-app VNet.

C:

A string variable alone is not a Bicep existing-resource declaration and does not ensure a service-backed reference to the stated resource.

Question 416

A Bicep file already declares storage-account resource `st` and child `Microsoft.Storage/storageAccounts/blobServices` resource `svc` (name `default`, parent `st`). It must declare a NEW Blob container named `invoices` as a separate resource block. The team's enforced `use-parent-property` linter rule rejects concatenating the complete `st/default/invoices` name into the child block. Which declaration correctly models the container without redeploying or misidentifying its parent?

  1. Declare `Microsoft.Storage/storageAccounts/blobServices/containers` with `parent: st` and `name: invoices`; the storage account is the immediate parent of a container.
  2. Declare a new storage account resource named `invoices` and set its tags to show the original account and Blob service; tags establish the container parent relationship.
  3. Keep `name: st/default/invoices`, omit parent, and disable the required linter policy; a full string path is mandatory for every Bicep child.
  4. Declare the `Microsoft.Storage/storageAccounts/blobServices/containers` resource with `name: invoices` and `parent: svc`; the Blob service symbol is the immediate parent already attached to st.

Explanation

Correct Answer

D:

In a separate Bicep declaration, the child container uses the full resource type `Microsoft.Storage/storageAccounts/blobServices/containers`, its own short name `invoices`, and `parent: svc`. The svc symbol already has `parent: st`, so Bicep derives the full storage account / default service / invoices path and satisfies the enforced parent-property linter without duplicating the account.

Incorrect Answers

A:

The hierarchy for a Blob container is storage account / Blob service / container. When using Bicep `parent`, the parent of a `blobServices/containers` resource is the Blob service symbol, not the storage account directly. `parent: st` skips a required resource type level and does not represent the child resource correctly.

B:

A storage account resource is a different management-plane resource type from an individual Blob container. Tags merely annotate resources and do not establish the `blobServices/containers` parent relationship or provision an Azure Blob container within the existing storage account. This creates the wrong resource rather than the intended child.

C:

A fully qualified child-resource name can sometimes be authored in a separate declaration, but it is specifically the style that violates the enforced use-parent-property lint rule in this case. Disabling a required quality gate does not meet the requested code standard. Bicep supports a direct parent property and a short child name instead.

Question 417

A Bicep deployment needs a tag object applied to several resources. What should the administrator do to resolve this specific case?

  1. Specify the existing resource's scope and supported cross-scope reference.
  2. Use an `if` conditional expression on the Bicep declaration rather than comment out its resource.
  3. Parameterize the prefix and use supported uniqueString input for a deterministic unique name.
  4. Define a shared tags object or parameter and reference it in each resource declaration.

Explanation

Correct Answer

D:

Defining a reusable `tags` object or parameter once and referencing it in each resource declaration applies the same tag keys and values consistently. Updating the common object then changes intended tags across those declarations without copying separate literal maps.

Incorrect Answers

A:

A cross-scope existing-resource reference locates a deployed object without creating it; it does not remedy the resource definition or parameter behavior at issue.

B:

A Bicep `if` condition decides whether to deploy a resource or module. Even when a resource is deployed, that condition does not supply a shared tag set to multiple resources. Define a reusable tags object or parameter and reference it in each applicable resource's `tags` property.

C:

A `uniqueString()`-based suffix addresses deterministic resource-name generation. The requested maintenance problem is reuse of one tags object, so changing names does not apply those tags to the resources.

Question 418

An explicit Bicep dependsOn array duplicates an inferred symbolic resource dependency. Which change addresses the stated situation most precisely?

  1. Use symbolic property references when appropriate and remove unnecessary manual dependency.
  2. Define a shared tags object or parameter and reference it in each resource declaration.
  3. Update the resource type version and property shape based on provider documentation.
  4. Move the network definition into a module with explicit parameters and outputs.

Explanation

Correct Answer

A:

Bicep infers deployment ordering when a resource property symbolically references another declared resource. Keeping the symbolic reference and removing a redundant manual `dependsOn` avoids needless ordering declarations while retaining the real dependency.

Incorrect Answers

B:

Defining shared tags changes Azure resource metadata, not Bicep dependency calculation. In this file the `dependsOn` entry duplicates a dependency already inferred from the symbolic resource reference, so the required simplification is to remove the redundant array.

C:

An API-version/schema change corrects resource property compatibility, not the input validation or module wiring specified by this case.

D:

A Bicep module is a reusable unit of deployment and can accept parameters and return outputs. Extracting a network definition into a module would change code organization, but it would not address an unnecessary explicit `dependsOn`. Symbolic references already produce implicit dependencies, so remove the redundant entry after checking the actual reference graph.

Question 419

A Bicep module must deploy six similarly configured storage accounts into one approved resource group. The account names must differ by index, and the team wants a single declaration rather than six copied resource blocks. Which Bicep mechanism addresses this requirement?

  1. Put an `@allowed` decorator on the storage-account name parameter but keep only one resource declaration.
  2. Declare a resource collection using a `for` expression over six indices, giving each storage account a distinct valid name.
  3. Add an `if` conditional to one resource declaration without introducing an iteration.
  4. Create a variable holding six names but never iterate through that collection in a resource declaration.

Explanation

Correct Answer

B:

Bicep resource loops can create multiple instances from an integer range or a collection while keeping a single resource declaration. A loop index can contribute to the unique account name, which must also satisfy storage naming requirements. The module can parameterize the count and other shared configuration while generating six independent resources. This directly avoids maintaining six nearly identical blocks and is the supported mechanism documented for repeating deployments.

Incorrect Answers

A:

An allowed-value parameter decorator limits acceptable inputs but does not create multiple copies of a resource. With only one resource declaration, Bicep would still request one storage account. The case requires repeated instances with distinct names, so input validation is useful only after the appropriate iteration structure is defined.

C:

An `if` expression controls whether a resource instance is deployed based on a condition. By itself it does not repeat the resource six times, even if the condition is true. Bicep supports combining loops and conditions, but the essential missing mechanism for this case is iteration.

D:

A variable containing a list of names is inert until another resource or module declaration consumes it. Simply defining six strings does not ask Azure Resource Manager to create six storage accounts. The declaration needs to use the collection in a `for` loop or an equivalent supported iterative construct.

Question 420

A Bicep deployment runs at resource-group scope rg-app, but it must read the ID of an existing storage account stshared located in another resource group rg-data in the same subscription. What must its Bicep resource reference include?

  1. Declare the account as `existing` with the right name but omit `scope`; Bicep automatically searches all resource groups in the subscription.
  2. Declare a brand new storage account named stshared in rg-app because Bicep cannot reference an account in another resource group.
  3. Use an `if` condition on a new local resource declaration instead of setting a resource scope.
  4. Declare stshared as `existing` and set its scope explicitly to `resourceGroup('rg-data')` so its symbolic ID resolves to the other resource group.

Explanation

Correct Answer

D:

The `existing` modifier prevents redeployment, while `scope: resourceGroup('rg-data')` tells Bicep which resource group contains the referenced account. Both details matter.

Incorrect Answers

A:

Without an explicit different scope, a resource declaration resolves relative to its deployment scope. Bicep does not automatically discover resources by name across resource groups.

B:

Bicep supports a cross-resource-group existing-resource reference. Creating a second account produces the wrong identity and is unnecessary.

C:

Conditionally creating a local resource does not bind a symbol to an existing account in rg-data. The location of the existing resource must be specified.