McAfee-Secured Website

Exam Code: AI-300

Exam Name: Operationalizing Machine Learning and Generative AI Solutions

Certification Provider: Microsoft

Corresponding Certification: Microsoft Certified: Machine Learning Operations Engineer Associate

100% Microsoft AI-300 Guaranteed Success With Testking Training Materials

Get Real AI-300 Exam Questions & Expert Verified Answers as Experienced on the Real Exam!

213 Questions & Answers with Testing Engine

"Operationalizing Machine Learning and Generative AI Solutions Exam", also known as AI-300 exam, is a Microsoft certification exam.

Pass your tests with the always up-to-date AI-300 Exam Engine. Your AI-300 training materials keep you at the head of the pack!

Satisfaction Guaranteed

Money Back Guarantee

Testking provides hassle-free money back guarantee with our products. That is because we have 100% trust in the abilities of our professional and experience product team, and our record is a proof of that.

99.6% PASS RATE
Was: $137.49
Now: $124.99

Microsoft AI-300 Practice Test 45

Question 440

A production Bicep change could remove a private endpoint, and the security team wants review before application. What should run first?

  1. Execute a deployment what-if preview with the exact target parameters.
  2. Deploy the Foundry platform from version-controlled Bicep infrastructure definitions.
  3. Keep reusable Bicep modules with approved environment-specific region and model parameters.
  4. Declare mandatory resource tags and naming conventions in provisioning modules.

Explanation

Correct Answer

A:

What-if shows planned resource changes for review before an infrastructure update affects service network controls.

Incorrect Answers

B:

Deploy the Foundry platform from version-controlled Bicep infrastructure definitions. A separate source case supports that approach when: A platform team repeatedly provisions Foundry projects manually, causing inconsistent tags and identity settings. The supporting rationale or observable result is: Declarative templates make project resources and settings reproducible across multiple environments and reviewer-approved releases. This question describes a different issue: A production Bicep change could remove a private endpoint, and the security team wants review before application. Address it through Execute a deployment what-if preview with the exact target parameters, with the required justification or evidence: What-if shows planned resource changes for review before an infrastructure update affects service network controls.

C:

Keep reusable Bicep modules with approved environment-specific region and model parameters. This is useful for the distinct issue: Different regions require different model deployment configurations but the team wants one shared infrastructure source. The relevant technical rationale or evidence for that issue is: Parameter files separate permitted environment variations from the centrally reviewed provisioning logic. Here the reported issue is: A production Bicep change could remove a private endpoint, and the security team wants review before application. The relevant response is: Execute a deployment what-if preview with the exact target parameters. The first result cannot verify this different correction: What-if shows planned resource changes for review before an infrastructure update affects service network controls.

D:

Declare mandatory resource tags and naming conventions in provisioning modules. It addresses another case: A new Foundry project is deployed without the expected cost center and owner information. For that case, the distinguishing justification or acceptance check is: Consistent metadata supports cost attribution and operational ownership across automatically created projects. The present case instead states: A production Bicep change could remove a private endpoint, and the security team wants review before application. It calls for Execute a deployment what-if preview with the exact target parameters. Showing success for the other case would not establish: What-if shows planned resource changes for review before an infrastructure update affects service network controls.

Question 441

A Foundry model application uses a hard-coded endpoint URL copied from staging in its Bicep output script. What is the right handoff?

  1. Reconcile the approved change into the version-controlled IaC source before redeployment.
  2. Deploy the Foundry platform from version-controlled Bicep infrastructure definitions.
  3. Reference declared resource symbols and computed IDs rather than copied resource identifiers.
  4. Expose the generated resource endpoint as an infrastructure deployment output.

Explanation

Correct Answer

D:

Resource outputs avoid stale manually copied endpoints and allow applications to consume the address of the actual environment.

Incorrect Answers

A:

Reconcile the approved change into the version-controlled IaC source before redeployment. That operation would be relevant if: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. Its corresponding reason or verification is: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences. However the problem in this question is: A Foundry model application uses a hard-coded endpoint URL copied from staging in its Bicep output script. The requirement instead calls for Expose the generated resource endpoint as an infrastructure deployment output; the question-specific check is: Resource outputs avoid stale manually copied endpoints and allow applications to consume the address of the actual environment.

B:

Deploy the Foundry platform from version-controlled Bicep infrastructure definitions. A separate source case supports that approach when: A platform team repeatedly provisions Foundry projects manually, causing inconsistent tags and identity settings. The supporting rationale or observable result is: Declarative templates make project resources and settings reproducible across multiple environments and reviewer-approved releases. This question describes a different issue: A Foundry model application uses a hard-coded endpoint URL copied from staging in its Bicep output script. Address it through Expose the generated resource endpoint as an infrastructure deployment output, with the required justification or evidence: Resource outputs avoid stale manually copied endpoints and allow applications to consume the address of the actual environment.

C:

Reference declared resource symbols and computed IDs rather than copied resource identifiers. This is useful for the distinct issue: A Bicep resource references a literal project ID from the wrong environment and deployment binds to staging. The relevant technical rationale or evidence for that issue is: Symbolic expressions resolve resources from the current deployment context and reduce accidental cross-environment coupling. Here the reported issue is: A Foundry model application uses a hard-coded endpoint URL copied from staging in its Bicep output script. The relevant response is: Expose the generated resource endpoint as an infrastructure deployment output. The first result cannot verify this different correction: Resource outputs avoid stale manually copied endpoints and allow applications to consume the address of the actual environment.

Question 442

A GitHub workflow deploys a Foundry project but fails because the responsible Azure resource provider is not registered in a new subscription. What should the platform team validate?

  1. Order role assignments after the resource and managed identity have been created.
  2. Reconcile the approved change into the version-controlled IaC source before redeployment.
  3. Confirm required resource-provider registration and subscription prerequisites before deployment.
  4. Use secure parameters and approved secret management or managed identity instead of checked-in keys.

Explanation

Correct Answer

C:

Resource creation can fail at the provider boundary even with valid templates and sufficient user permissions.

Incorrect Answers

A:

The alternative, Order role assignments after the resource and managed identity have been created, belongs to a different technical condition: A Foundry project's managed identity cannot be used during provisioning because the role assignment runs before the identity exists. There the source-specific mechanism or proof is: Identity principal IDs are available only after the owning resource exists, so permissions require correct dependency sequencing. The condition asked about here is: A GitHub workflow deploys a Foundry project but fails because the responsible Azure resource provider is not registered in a new subscription. A suitable correction is Confirm required resource-provider registration and subscription prerequisites before deployment; the targeted justification or result is: Resource creation can fail at the provider boundary even with valid templates and sufficient user permissions.

B:

Reconcile the approved change into the version-controlled IaC source before redeployment. That operation would be relevant if: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. Its corresponding reason or verification is: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences. However the problem in this question is: A GitHub workflow deploys a Foundry project but fails because the responsible Azure resource provider is not registered in a new subscription. The requirement instead calls for Confirm required resource-provider registration and subscription prerequisites before deployment; the question-specific check is: Resource creation can fail at the provider boundary even with valid templates and sufficient user permissions.

D:

Use secure parameters and approved secret management or managed identity instead of checked-in keys. A separate source case supports that approach when: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. The supporting rationale or observable result is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment. This question describes a different issue: A GitHub workflow deploys a Foundry project but fails because the responsible Azure resource provider is not registered in a new subscription. Address it through Confirm required resource-provider registration and subscription prerequisites before deployment, with the required justification or evidence: Resource creation can fail at the provider boundary even with valid templates and sufficient user permissions.

Question 443

A security architect sees plaintext API keys in infrastructure parameter files stored in Git. What change is required?

  1. Extract reviewed reusable Bicep modules for shared private connectivity patterns.
  2. Use secure parameters and approved secret management or managed identity instead of checked-in keys.
  3. Select the approved subscription and resource-group deployment scope explicitly.
  4. Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs.

Explanation

Correct Answer

B:

Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment.

Incorrect Answers

A:

Extract reviewed reusable Bicep modules for shared private connectivity patterns. It addresses another case: A project has several repeated networking resources duplicated across Bicep files. For that case, the distinguishing justification or acceptance check is: Shared modules centralize common infrastructure logic while parameters identify environment-specific addresses and names. The present case instead states: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. It calls for Use secure parameters and approved secret management or managed identity instead of checked-in keys. Showing success for the other case would not establish: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment.

C:

The alternative, Select the approved subscription and resource-group deployment scope explicitly, belongs to a different technical condition: An Azure CLI deployment targets the wrong subscription because a developer last logged in to their sandbox. There the source-specific mechanism or proof is: CLI context determines where resources are provisioned; a validated template can still deploy into the wrong subscription. The condition asked about here is: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. A suitable correction is Use secure parameters and approved secret management or managed identity instead of checked-in keys; the targeted justification or result is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment.

D:

Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs. That operation would be relevant if: A deployment needs to identify which source revision created a Foundry production resource after an incident. Its corresponding reason or verification is: Source and deployment provenance support reconstructing approved infrastructure state from a historical release. However the problem in this question is: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. The requirement instead calls for Use secure parameters and approved secret management or managed identity instead of checked-in keys; the question-specific check is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment.

Question 444

An IaC deployment uses a random resource-name suffix on each run, creating unnecessary duplicate Foundry resources. Which change improves repeatability?

  1. Adopt stable deterministic naming and idempotent Bicep resource declarations.
  2. Run Bicep build and ARM validation before applying the deployment.
  3. Use secure parameters and approved secret management or managed identity instead of checked-in keys.
  4. Reconcile the approved change into the version-controlled IaC source before redeployment.

Explanation

Correct Answer

A:

Repeated deployments should update intended resources without accidentally multiplying billable project infrastructure.

Incorrect Answers

B:

Run Bicep build and ARM validation before applying the deployment. This is useful for the distinct issue: A Foundry platform's production deployment fails schema validation before resources are created. The relevant technical rationale or evidence for that issue is: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur. Here the reported issue is: An IaC deployment uses a random resource-name suffix on each run, creating unnecessary duplicate Foundry resources. The relevant response is: Adopt stable deterministic naming and idempotent Bicep resource declarations. The first result cannot verify this different correction: Repeated deployments should update intended resources without accidentally multiplying billable project infrastructure.

C:

Use secure parameters and approved secret management or managed identity instead of checked-in keys. It addresses another case: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. For that case, the distinguishing justification or acceptance check is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment. The present case instead states: An IaC deployment uses a random resource-name suffix on each run, creating unnecessary duplicate Foundry resources. It calls for Adopt stable deterministic naming and idempotent Bicep resource declarations. Showing success for the other case would not establish: Repeated deployments should update intended resources without accidentally multiplying billable project infrastructure.

D:

The alternative, Reconcile the approved change into the version-controlled IaC source before redeployment, belongs to a different technical condition: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. There the source-specific mechanism or proof is: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences. The condition asked about here is: An IaC deployment uses a random resource-name suffix on each run, creating unnecessary duplicate Foundry resources. A suitable correction is Adopt stable deterministic naming and idempotent Bicep resource declarations; the targeted justification or result is: Repeated deployments should update intended resources without accidentally multiplying billable project infrastructure.

Question 445

A Foundry project's managed identity cannot be used during provisioning because the role assignment runs before the identity exists. What should be declared?

  1. Use secure parameters and approved secret management or managed identity instead of checked-in keys.
  2. Expose the generated resource endpoint as an infrastructure deployment output.
  3. Reconcile the approved change into the version-controlled IaC source before redeployment.
  4. Order role assignments after the resource and managed identity have been created.

Explanation

Correct Answer

D:

Identity principal IDs are available only after the owning resource exists, so permissions require correct dependency sequencing.

Incorrect Answers

A:

Use secure parameters and approved secret management or managed identity instead of checked-in keys. A separate source case supports that approach when: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. The supporting rationale or observable result is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment. This question describes a different issue: A Foundry project's managed identity cannot be used during provisioning because the role assignment runs before the identity exists. Address it through Order role assignments after the resource and managed identity have been created, with the required justification or evidence: Identity principal IDs are available only after the owning resource exists, so permissions require correct dependency sequencing.

B:

Expose the generated resource endpoint as an infrastructure deployment output. This is useful for the distinct issue: A Foundry model application uses a hard-coded endpoint URL copied from staging in its Bicep output script. The relevant technical rationale or evidence for that issue is: Resource outputs avoid stale manually copied endpoints and allow applications to consume the address of the actual environment. Here the reported issue is: A Foundry project's managed identity cannot be used during provisioning because the role assignment runs before the identity exists. The relevant response is: Order role assignments after the resource and managed identity have been created. The first result cannot verify this different correction: Identity principal IDs are available only after the owning resource exists, so permissions require correct dependency sequencing.

C:

Reconcile the approved change into the version-controlled IaC source before redeployment. It addresses another case: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. For that case, the distinguishing justification or acceptance check is: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences. The present case instead states: A Foundry project's managed identity cannot be used during provisioning because the role assignment runs before the identity exists. It calls for Order role assignments after the resource and managed identity have been created. Showing success for the other case would not establish: Identity principal IDs are available only after the owning resource exists, so permissions require correct dependency sequencing.

Question 446

An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. What governance process should be enforced?

  1. Deploy the Foundry platform from version-controlled Bicep infrastructure definitions.
  2. Execute a deployment what-if preview with the exact target parameters.
  3. Reconcile the approved change into the version-controlled IaC source before redeployment.
  4. Run Bicep build and ARM validation before applying the deployment.

Explanation

Correct Answer

C:

Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences.

Incorrect Answers

A:

Deploy the Foundry platform from version-controlled Bicep infrastructure definitions. That operation would be relevant if: A platform team repeatedly provisions Foundry projects manually, causing inconsistent tags and identity settings. Its corresponding reason or verification is: Declarative templates make project resources and settings reproducible across multiple environments and reviewer-approved releases. However the problem in this question is: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. The requirement instead calls for Reconcile the approved change into the version-controlled IaC source before redeployment; the question-specific check is: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences.

B:

Execute a deployment what-if preview with the exact target parameters. A separate source case supports that approach when: A production Bicep change could remove a private endpoint, and the security team wants review before application. The supporting rationale or observable result is: What-if shows planned resource changes for review before an infrastructure update affects service network controls. This question describes a different issue: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. Address it through Reconcile the approved change into the version-controlled IaC source before redeployment, with the required justification or evidence: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences.

D:

Run Bicep build and ARM validation before applying the deployment. This is useful for the distinct issue: A Foundry platform's production deployment fails schema validation before resources are created. The relevant technical rationale or evidence for that issue is: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur. Here the reported issue is: An engineer edits the production Foundry resource directly in the portal, making the next declared deployment revert changes. The relevant response is: Reconcile the approved change into the version-controlled IaC source before redeployment. The first result cannot verify this different correction: Infrastructure drift should be resolved through reviewed source rather than accumulating untracked portal differences.

Question 447

A new Foundry project is deployed without the expected cost center and owner information. How should the template enforce governance?

  1. Run Bicep build and ARM validation before applying the deployment.
  2. Declare mandatory resource tags and naming conventions in provisioning modules.
  3. Keep reusable Bicep modules with approved environment-specific region and model parameters.
  4. Adopt stable deterministic naming and idempotent Bicep resource declarations.

Explanation

Correct Answer

B:

Consistent metadata supports cost attribution and operational ownership across automatically created projects.

Incorrect Answers

A:

The alternative, Run Bicep build and ARM validation before applying the deployment, belongs to a different technical condition: A Foundry platform's production deployment fails schema validation before resources are created. There the source-specific mechanism or proof is: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur. The condition asked about here is: A new Foundry project is deployed without the expected cost center and owner information. A suitable correction is Declare mandatory resource tags and naming conventions in provisioning modules; the targeted justification or result is: Consistent metadata supports cost attribution and operational ownership across automatically created projects.

C:

Keep reusable Bicep modules with approved environment-specific region and model parameters. That operation would be relevant if: Different regions require different model deployment configurations but the team wants one shared infrastructure source. Its corresponding reason or verification is: Parameter files separate permitted environment variations from the centrally reviewed provisioning logic. However the problem in this question is: A new Foundry project is deployed without the expected cost center and owner information. The requirement instead calls for Declare mandatory resource tags and naming conventions in provisioning modules; the question-specific check is: Consistent metadata supports cost attribution and operational ownership across automatically created projects.

D:

Adopt stable deterministic naming and idempotent Bicep resource declarations. A separate source case supports that approach when: An IaC deployment uses a random resource-name suffix on each run, creating unnecessary duplicate Foundry resources. The supporting rationale or observable result is: Repeated deployments should update intended resources without accidentally multiplying billable project infrastructure. This question describes a different issue: A new Foundry project is deployed without the expected cost center and owner information. Address it through Declare mandatory resource tags and naming conventions in provisioning modules, with the required justification or evidence: Consistent metadata supports cost attribution and operational ownership across automatically created projects.

Question 448

A Foundry platform's production deployment fails schema validation before resources are created. What should CI execute?

  1. Run Bicep build and ARM validation before applying the deployment.
  2. Reference declared resource symbols and computed IDs rather than copied resource identifiers.
  3. Require policy and change approval gates before running production IaC updates.
  4. Declare symbolic dependencies on the parent Foundry resource before creating the project.

Explanation

Correct Answer

A:

Static and provider schema checks catch unsupported property structures before live infrastructure changes occur.

Incorrect Answers

B:

Reference declared resource symbols and computed IDs rather than copied resource identifiers. It addresses another case: A Bicep resource references a literal project ID from the wrong environment and deployment binds to staging. For that case, the distinguishing justification or acceptance check is: Symbolic expressions resolve resources from the current deployment context and reduce accidental cross-environment coupling. The present case instead states: A Foundry platform's production deployment fails schema validation before resources are created. It calls for Run Bicep build and ARM validation before applying the deployment. Showing success for the other case would not establish: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur.

C:

The alternative, Require policy and change approval gates before running production IaC updates, belongs to a different technical condition: Azure CLI can create Foundry resources but an MLOps pipeline updates them without any pre-release approval. There the source-specific mechanism or proof is: Infrastructure automation still needs authorization to prevent unreviewed changes to security or billable AI resources. The condition asked about here is: A Foundry platform's production deployment fails schema validation before resources are created. A suitable correction is Run Bicep build and ARM validation before applying the deployment; the targeted justification or result is: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur.

D:

Declare symbolic dependencies on the parent Foundry resource before creating the project. That operation would be relevant if: A Bicep deployment creates a Foundry project before its required parent resource exists. Its corresponding reason or verification is: Resource dependencies ensure the deployment service can order creation correctly rather than referencing missing parent IDs. However the problem in this question is: A Foundry platform's production deployment fails schema validation before resources are created. The requirement instead calls for Run Bicep build and ARM validation before applying the deployment; the question-specific check is: Static and provider schema checks catch unsupported property structures before live infrastructure changes occur.

Question 449

A project has several repeated networking resources duplicated across Bicep files. What architectural change reduces drift?

  1. Confirm required resource-provider registration and subscription prerequisites before deployment.
  2. Keep reusable Bicep modules with approved environment-specific region and model parameters.
  3. Require policy and change approval gates before running production IaC updates.
  4. Extract reviewed reusable Bicep modules for shared private connectivity patterns.

Explanation

Correct Answer

D:

Shared modules centralize common infrastructure logic while parameters identify environment-specific addresses and names.

Incorrect Answers

A:

Confirm required resource-provider registration and subscription prerequisites before deployment. This is useful for the distinct issue: A GitHub workflow deploys a Foundry project but fails because the responsible Azure resource provider is not registered in a new subscription. The relevant technical rationale or evidence for that issue is: Resource creation can fail at the provider boundary even with valid templates and sufficient user permissions. Here the reported issue is: A project has several repeated networking resources duplicated across Bicep files. The relevant response is: Extract reviewed reusable Bicep modules for shared private connectivity patterns. The first result cannot verify this different correction: Shared modules centralize common infrastructure logic while parameters identify environment-specific addresses and names.

B:

Keep reusable Bicep modules with approved environment-specific region and model parameters. It addresses another case: Different regions require different model deployment configurations but the team wants one shared infrastructure source. For that case, the distinguishing justification or acceptance check is: Parameter files separate permitted environment variations from the centrally reviewed provisioning logic. The present case instead states: A project has several repeated networking resources duplicated across Bicep files. It calls for Extract reviewed reusable Bicep modules for shared private connectivity patterns. Showing success for the other case would not establish: Shared modules centralize common infrastructure logic while parameters identify environment-specific addresses and names.

C:

The alternative, Require policy and change approval gates before running production IaC updates, belongs to a different technical condition: Azure CLI can create Foundry resources but an MLOps pipeline updates them without any pre-release approval. There the source-specific mechanism or proof is: Infrastructure automation still needs authorization to prevent unreviewed changes to security or billable AI resources. The condition asked about here is: A project has several repeated networking resources duplicated across Bicep files. A suitable correction is Extract reviewed reusable Bicep modules for shared private connectivity patterns; the targeted justification or result is: Shared modules centralize common infrastructure logic while parameters identify environment-specific addresses and names.

Question 450

A deployment needs to identify which source revision created a Foundry production resource after an incident. What should automation record?

  1. Keep reusable Bicep modules with approved environment-specific region and model parameters.
  2. Select the approved subscription and resource-group deployment scope explicitly.
  3. Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs.
  4. Use secure parameters and approved secret management or managed identity instead of checked-in keys.

Explanation

Correct Answer

C:

Source and deployment provenance support reconstructing approved infrastructure state from a historical release.

Incorrect Answers

A:

Keep reusable Bicep modules with approved environment-specific region and model parameters. This is useful for the distinct issue: Different regions require different model deployment configurations but the team wants one shared infrastructure source. The relevant technical rationale or evidence for that issue is: Parameter files separate permitted environment variations from the centrally reviewed provisioning logic. Here the reported issue is: A deployment needs to identify which source revision created a Foundry production resource after an incident. The relevant response is: Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs. The first result cannot verify this different correction: Source and deployment provenance support reconstructing approved infrastructure state from a historical release.

B:

Select the approved subscription and resource-group deployment scope explicitly. It addresses another case: An Azure CLI deployment targets the wrong subscription because a developer last logged in to their sandbox. For that case, the distinguishing justification or acceptance check is: CLI context determines where resources are provisioned; a validated template can still deploy into the wrong subscription. The present case instead states: A deployment needs to identify which source revision created a Foundry production resource after an incident. It calls for Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs. Showing success for the other case would not establish: Source and deployment provenance support reconstructing approved infrastructure state from a historical release.

D:

The alternative, Use secure parameters and approved secret management or managed identity instead of checked-in keys, belongs to a different technical condition: A security architect sees plaintext API keys in infrastructure parameter files stored in Git. There the source-specific mechanism or proof is: Infrastructure source history should not distribute credentials; sensitive values must be injected securely at deployment. The condition asked about here is: A deployment needs to identify which source revision created a Foundry production resource after an incident. A suitable correction is Capture the IaC commit SHA, deployment ID, parameter set, and resulting resource IDs; the targeted justification or result is: Source and deployment provenance support reconstructing approved infrastructure state from a historical release.

Operationalizing Machine Learning and Generative AI Solutions (AI-300) Practice Tests