AZ-400 Practice Questions & Answers

Loading your practice set…

In an Azure DevOps environment, you need to integrate GitHub Enterprise with Azure Boards using a Git repository. Which tool or service should you use to facilitate this integration?

Azure Pipelines
GitHub Extension for Azure DevOps (Correct)
Azure Functions
Azure API Management

Explanation: Azure DevOps Services provide a built-in integration with GitHub Enterprise through the 'GitHub' extension in Azure DevOps. This allows you to connect your GitHub repositories directly to Azure Boards for seamless work item management and sprint planning. Options A, C, and D do not offer direct integration capabilities between Azure DevOps and GitHub Enterprise.

Your team is working on a project that requires linking work items from Azure Boards to GitHub issues. How would you achieve this linkage effectively?

Directly linking work items in Azure Boards to GitHub issues
Using the GitHub Extension for Azure DevOps (Correct)
Creating custom scripts to manually link issues
Using Azure API Management to create custom integrations

Explanation: To link work items from Azure Boards to GitHub issues, you can use the 'GitHub' extension in Azure DevOps to connect your GitHub repositories with Azure Boards. Once connected, you can create work items in Azure Boards and link them to specific GitHub issues. Options A, C, and D do not provide the necessary integration or linking functionality.

In a scenario where a team is working on a large-scale application with multiple developers, which branching strategy would you recommend to maintain a stable production environment while allowing for parallel development and feature branches? Explain your choice and how it aligns with branch policies and pull request reviews.

Trunk-based development (Correct)
GitFlow
Feature-branching
Release-branching

Explanation: Trunk-based development is recommended in this scenario because it allows for frequent and small commits directly into the trunk, ensuring that the production codebase remains stable. This approach also supports parallel development through feature branches that are merged back into the trunk after thorough testing and review via pull requests. The use of branch policies can enforce coding standards and security checks, while pull request reviews ensure code quality and alignment with project goals.

A developer needs to make a critical bug fix in the production codebase without disrupting ongoing development work. Which branching strategy and process should they follow to ensure the fix is applied correctly and reviewed before being merged back into the main branch?

Create a hotfix branch from the current production branch (Correct)
Create a new feature branch and merge it into the trunk
Directly modify the production branch
Use GitFlow to create a release branch for the fix

Explanation: For a critical bug fix, the developer should create a hotfix branch from the current production branch, apply the fix, and then merge it back into both the production and development branches after thorough testing and review via pull requests. This process ensures that the fix is isolated, tested, and reviewed before being integrated into the main codebase, maintaining the stability of the production environment.

In a scenario where you need to design an Azure Pipeline for a multi-stage CI/CD process, which of the following is the best approach to ensure that the self-hosted build agents are utilized effectively and the test automation is integrated seamlessly?

Use Azure Pipelines for all stages and integrate tests at the end.
Use self-hosted build agents for pre-production stages and Azure Pipelines for the rest. (Correct)
Use only Azure Pipelines for all stages and integrate tests at each stage.
Use self-hosted build agents for all stages and integrate tests at the end.

Explanation: The correct answer is B because it ensures that the self-hosted build agents are used for specific stages, such as pre-production, while leveraging Azure Pipelines for the rest of the pipeline. This approach maximizes the use of on-premises resources for sensitive or performance-critical tasks. Option A is incorrect because it does not specify the use of self-hosted agents for specific stages. Option C is incorrect because it suggests using only Azure Pipelines, which may not leverage the benefits of self-hosted agents. Option D is incorrect because it does not provide a clear strategy for integrating test automation.

When designing a CI/CD pipeline in Azure Pipelines, you need to ensure that the test automation scripts run on a self-hosted agent before deploying to production. Which YAML snippet correctly configures this requirement in a multi-stage pipeline?

- stage: Test jobs: - job: Tests pool: name: 'Default Agent Pool' steps: - script: echo Testing...
- stage: Test jobs: - job: Tests pool: name: 'SelfHostedAgentPool' steps: - script: echo Testing... (Correct)
- stage: Test jobs: - job: Tests pool: name: 'MySelfHostedAgents' steps: - script: echo Testing...
- stage: Test jobs: - job: Tests pool: name: 'SelfHostedAgentsPool' steps: - script: echo Testing...

Explanation: The correct answer is B because it specifies the use of a self-hosted agent pool for the test stage, ensuring that the test automation scripts run on a dedicated environment before deployment. Option A is incorrect because it does not specify the agent pool, which could lead to the use of any available agent. Option C is incorrect because it incorrectly names the agent pool, which would cause errors. Option D is incorrect because it does not specify the agent pool and uses an invalid syntax.

In a scenario where you need to ensure that a new version of an application is thoroughly tested before it is rolled out to production, which release gate should you implement in your continuous delivery pipeline?

Automated testing
Manual approval gate (Correct)
Automated deployment
Continuous integration

Explanation: The correct answer is B because a manual approval gate allows the team to review and approve the deployment before it proceeds to the next stage. This ensures that the new version is thoroughly tested and meets the necessary quality standards. Option A (Automated testing) is important but does not provide the final human approval needed before deployment. Option C (Automated deployment) would bypass the need for any review or approval, which goes against the principle of ensuring quality before deployment. Option D (Continuous integration) is a practice used to integrate code changes from multiple contributors into a single software project, but it does not address the need for a final approval before deployment.

Your organization wants to minimize downtime during a deployment by using a blue-green deployment strategy. Which of the following best describes this approach?

Canary release
Two identical environments running different versions of the application (Correct)
Rolling update
Blue-green deployment with gradual rollout

Explanation: The correct answer is B because in a blue-green deployment, two identical environments (blue and green) exist, each running a different version of the application. The traffic is initially directed to the 'blue' environment, and once the new version is validated, the traffic is switched to the 'green' environment. This minimizes downtime as the transition happens without interrupting service. Option A (Canary release) involves gradually rolling out the new version to a small subset of users to test before full deployment. Option C (Rolling update) involves updating one instance at a time, which can cause temporary downtime. Option D (Blue-green deployment with gradual rollout) combines elements of both blue-green and canary strategies, but the pure blue-green method does not include a gradual rollout component.

In a scenario where you are implementing dependency scanning using WhiteSource to identify and mitigate security vulnerabilities in your Azure DevOps pipeline, which of the following steps should you take to ensure that the pipeline only deploys if all dependencies are secure?

Manually review each dependency before deployment.
Configure the pipeline to fail the build if any dependency has a vulnerability. (Correct)
Notify the development team via email if any dependency has a vulnerability.
Allow the pipeline to continue regardless of the security checks.

Explanation: The correct answer is B because it ensures that the pipeline will not proceed to the next stage if any of the dependencies have known vulnerabilities. Option A is incorrect as it does not address the security check. Option C is incorrect as it suggests a manual intervention which is not ideal for an automated pipeline. Option D is incorrect as it implies that the pipeline will always deploy regardless of the security checks.

When integrating SonarQube quality gates into your Azure DevOps pipeline to enforce code quality and security standards, which of the following actions should you perform to ensure that the pipeline only proceeds to the next stage if the code meets the predefined quality criteria?

Run unit tests on the code before the quality gate check.
Configure the pipeline to skip the next phase if the SonarQube analysis fails. (Correct)
Notify the development team via email if the SonarQube analysis fails.
Allow the pipeline to continue regardless of the SonarQube analysis results.

Explanation: The correct answer is B because it ensures that the pipeline will only proceed if the code meets the predefined quality criteria. Option A is incorrect as it does not address the quality gate functionality. Option C is incorrect as it suggests a manual intervention which is not ideal for an automated pipeline. Option D is incorrect as it implies that the pipeline will always proceed regardless of the quality checks.

In a scenario where you need to monitor the performance of an Azure Web App and receive alerts when the CPU usage exceeds 80%, which of the following actions should you take to configure this using Application Insights?

Create an alert in Azure Security Center based on security events.
Set up a custom metric in Application Insights to monitor CPU usage and create an alert based on that metric. (Correct)
Use Azure Log Analytics to query CPU usage and set up an alert based on the results.
Configure an alert in Azure Monitor Metrics for the Web App resource.

Explanation: The correct answer is B because you can set up custom metrics in Application Insights to monitor CPU usage and create alerts based on these metrics. Option A is incorrect as it pertains to Azure Monitor Metrics instead of Application Insights. Option C is incorrect as it involves setting up an alert in Azure Security Center, which is not relevant for monitoring CPU usage. Option D is incorrect as it refers to setting up an alert in Azure Log Analytics, which is also not the appropriate tool for this specific scenario.

You are tasked with ensuring that your Azure Function app is available 99.9% of the time. Which of the following methods would best help you achieve this goal by leveraging synthetic monitoring?

Enable custom logs in Application Insights to track user interactions.
Configure synthetic monitoring in Application Insights to simulate user traffic and check the availability of the Azure Function app. (Correct)
Set up real user monitoring to capture actual user traffic patterns and performance.
Create an alert in Azure Monitor for the Azure Function app resource.

Explanation: The correct answer is B because synthetic monitoring tools like Azure Application Insights can simulate user traffic to your application and provide insights into its availability and performance. Option A is incorrect as it pertains to setting up custom logs in Application Insights, which does not directly measure availability. Option C is incorrect as it involves configuring real user monitoring, which is not the same as synthetic monitoring. Option D is incorrect as it refers to setting up an alert in Azure Monitor, which is not specifically about synthetic monitoring.