Free AZ-400 Exam Dumps Preview

Managed Identity is suitable for scenarios where a single resource needs to access another Azure resource, while Service Principal is suitable for more complex scenarios where multiple resources need to access multiple Azure resources.

References:
https://www.c-sharpcorner.com/blogs/azure-managed-identity-vs-azure-service-principal

SonarCloud is a cloud service offered by SonarSource and based on SonarQube. SonarQube is a widely adopted open source platform to inspect continuously the quality of source code and detect bugs, vulnerabilities and code smells in more than 20 different languages.

Note: The SonarCloud Azure DevOps extension brings everything you need to have your projects analyzed on SonarCloud very quickly.

Incorrect Answers:
A: Test plans are used to group together test suites and individual test cases. This includes static test suites, requirement-based suites, and query-based suites.

References:
https://docs.travis-ci.com/user/sonarcloud/
https://sonarcloud.io/documentation/integrations/vsts/

A successful IOS device build will produce an ipa file. In order to install the build on a device, it needs to be signed with a valid provisioning profile and certificate. To sign the builds produced from a branch, enable code signing in the configuration pane and upload a provisioning profile (.mobileprovision) and a valid certificate (.p12), along with the password for the certificate.

References:
https://docs.microsoft.com/en-us/appcenter/build/xamarin/ios/

JIRA: Release pipelines
Atlassian's Jira Software is a popular application that helps teams to plan, track, and manage software releases, whereas Octopus Deploy helps teams automate their development and operations processes in a fast, repeatable, and reliable manner. Together, they enable teams to get better end-to-end visibility into their software pipelines from idea to production.

Jenkins: Repos
One way to integrate Jenkins with Azure Pipelines is to run CI jobs in Jenkins separately. This involves configuration of a CI pipeline in Jenkins and a web hook in Azure DevOps that invokes the CI process when source code is pushed to a repository or a branch.

Octopus: Build pipelines

References:
https://octopus.com/blog/octopus-jira-integration
https://www.azuredevopslabs.com/labs/vstsextend/jenkins/

Application Insights will tell you about any performance issues and exceptions, and help you find and diagnose the root causes.

Application Insights can monitor both Java and ASP.NET web applications and services, WCF services. They can be hosted on-premises, on virtual machines, or as Microsoft Azure websites.

On the client side, Application Insights can take telemetry from web pages and a wide variety of devices including iOS, Android, and Windows Store apps.

References:
https://docs.microsoft.com/en-us/azure/azure-monitor/app/web-monitor-performance

Task 1: Create a wiki for your project Azure DevOps, Create a wiki for your project

Step 1: In Project1, use the navigation to get to the Wiki hub.

Step 2: Since this project does not yet have its wiki configured, click Create project wiki to set one up.
When you create your first wiki, Azure DevOps will provision a Git repository that will store all your pages and artifacts.

Task 2: Render a diagram using the Mermaid syntax

The actual wiki diagram syntax is in the same file as your wiki document. The syntax for the Mermaid diagram is surrounded with the notation shown below.

:::mermaid
<Mermaid Syntax>

In the preview panel to the right of your text, the image below will be displayed. Clicking on Load diagram, the Mermaid syntax is used to generate the diagram.

Depending on desired output.

A. Flow Chart Example
:::mermaid
graph TD
A[Christmas] -->|Get money| B(Go shopping)
B --> C{Let me think}
C -->|One| D[Laptop]
C -->|Two| E[iPhone]
C -->|Three| F[fa-fa-fa Car]
:::

Generate a picture that looks like the below.

B. Sequence
:::mermaid
sequenceDiagram Alice->>John: Hello John, how are you?
loop Healthcheck John->>John: Fight against hypochondria
end Note right of John: Rational thoughts!
John-->>Alice: Great!
John->>Bob: How about you?
Bob-->>John: Jolly good!
:::

Generate a picture that looks like the below.

C. Gantt Chart
:::mermaid
gantt title A Gantt Diagram
dateFormat YYYY-MM-DD
section Section
A task :a1, 2014-01-01, 30d
Another task :after a1, 20d section Another Task in sec :2014-01-12, 12d another task :24d
:::

Generate a picture that looks like the below.

References:
https://www.azuredevopslabs.com/labs/azuredevops/wiki/
https://www.azuredevops.tips/wikimermaid-diagrams/

Box 1: A Build task Trigger a build
You have a Java code provisioned by the Azure DevOps demo generator. You will use WhiteSource Bolt extension to check the vulnerable components present in this code.

1. Go to Builds section under Pipelines tab, select the build definition WhiteSourceBolt and click on Queue to trigger a build.
2. To view the build in progress status, click on ellipsis and select View build results.

Box 2: WhiteSource Bolt
WhiteSource is the leader in continuous open source software security and compliance management. WhiteSource integrates into your build process, irrespective of your programming languages, build tools, or development environments. It works automatically, continuously, and silently in the background, checking the security, licensing, and quality of your open source components against WhiteSource constantly-updated definitive database of open source repositories.

References:
https://www.azuredevopslabs.com/labs/vstsextend/whitesource/

Explanation:
You can use OpenTelemetry Collector to collect traces to send to AppInsights. Run OpenTelemetry Collector to push to your Application Insights instance

Track incoming requests with OpenCensus Python Incoming request data is collected using OpenCensus Python and its various integrations. Track incoming request data sent to your web applications built on top of the popular web frameworks django, flask and pyramid. The data is then sent to Application Insights under Azure Monitor as requests telemetry.

References:
https://docs.dapr.io/operations/monitoring/tracing/otel-collector/open-telemetry-collector-appinsights/
https://learn.microsoft.com/en-us/azure/azure-monitor/app/opencensus-python-request

References:
https://www.scrum.org/resources/what-is-a-sprint-retrospective

Explanation:
The Dependency Tracker extension enables management of dependencies across teams, projects, and organizations. It provides filterable views to show all dependencies a team is consuming and producing. These views allow you to track the state and schedule of dependencies to support you in assessing the risk of dependencies to product deliverables.

You use the Dependency Tracker to plan dependencies at the beginning of an iteration or release, and to track the status during development. For any given dependency, there are two parties involved:

Consumer: Feature team who has a need and starts a request for work Producer: Feature team who makes a commitment to deliver work

References:
https://docs.microsoft.com/en-us/azure/devops/boards/extensions/dependency-tracker?view=azure-devops

Explanation:

Box 1: system.debug
To configure verbose logs for all runs, you can add a variable named system.debug and set its value to true.

Note: Verbose logging is the practice of recording to a persistent medium as much information as you possibly can about events that occur while the software runs.

Box 2: true

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/troubleshooting/review-logs

References:
https://marketplace.visualstudio.com/items?itemName=ms.vss-exploratorytesting-web

Azure Artifacts introduces the concept of multiple feeds that you can use to organize and control access to your packages.
Packages you host in Azure Artifacts are stored in a feed. Setting permissions on the feed allows you to share your packages with as many or as few people as your scenario requires.
Feeds have four levels of access: Owners, Contributors, Collaborators, and Readers.

References:
https://docs.microsoft.com/en-us/azure/devops/artifacts/feeds/feed-permissions?view=vsts&tabs=new-nav

References:
https://octopus.com/blog/octopus-jira-integration

Step 1: Create a DSC metaconfiguration Load up the DSC Configuration into Azure Automation.

Step 2: Copy the metaconfiguration to the virtual machines.
Linking the Node Configuration to the Linux Host

Step 3: Add the virtual machines as DSC nodes in Azure Automation. go to DSC Nodes, select your node, and then click Assign node configuration. This step assigns the DSC configuration to the Linux machine.
Next up will be to link the node configuration to the host. Go to the host and press the "Assign node..."-button. Next up you can select your node configuration.

E: GitLab CI/CD can be used with GitHub or any other Git server such as BitBucket. Instead of moving your entire project to GitLab, you can connect your external repository to get the benefits of GitLab CI/CD.

Note: When a pipeline uses a remote, 3rd-party repository host such as Bitbucket Cloud, the repository is configured with webhooks that notify Azure Pipelines Server or TFS when code has changed and a build should be triggered. Since on-premises installations are normally protected behind a firewall, 3rd-party webhooks are unable to reach the on-premises server. As a workaround, you can use the External Git repository type which uses polling instead of webhooks to trigger a build when code has changed.

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/repos/pipeline-options-for-git

Incorrect Answers:
A: You can seamlessly replace existing solutions with group-based licensing to more easily manage licenses in Azure DevOps. You can use Group rules.

C: Member Entitlement Management APIs allow managing Entitlements that include -
1. License
2. Extensions
3. Project/Team memberships

References:
https://docs.microsoft.com/en-us/azure/devops/organizations/accounts/migrate-to-group-based-resource-management?view=vsts&tabs=new-nav
https://docs.microsoft.com/en-us/rest/api/azure/devops/memberentitlementmanagement/?view=azure-devops-rest-5.0

Scenario: A branching strategy that supports developing new functionality in isolation must be used.

Feature isolation is a special derivation of the development isolation, allowing you to branch one or more feature branches from main, as shown, or from your dev branches.

When you need to work on a particular feature, it might be a good idea to create a feature branch.

References:
https://docs.microsoft.com/en-us/azure/devops/repos/tfvc/branching-strategies-with-tfvc?view=azure-devops

About Dependabot alerts, Detection of insecure dependencies Dependabot performs a scan of the default branch of your repository to detect insecure dependencies, and sends Dependabot alerts when:

A new advisory is added to the GitHub Advisory Database.
Note: Only advisories that have been reviewed by GitHub will trigger Dependabot alerts.

The dependency graph for a repository changes. For example, when a contributor pushes a commit to change the packages or versions it depends on, or when the code of one of the dependencies changes.

References:
https://docs.github.com/en/code-security/dependabot/working-with-dependabot/automating-dependabot-with-github-actions

You can develop in your codespace directly in Visual Studio Code by connecting the GitHub Codespaces extension with your account on GitHub.

References:
https://docs.github.com/en/codespaces/developing-in-codespaces/using-codespaces-in-visual-studio-code

Validation in the CI/CD begins before the developer commits his or her code. Static code analysis tools in the IDE provide the first line of defense to help ensure that security vulnerabilities are not introduced into the CI/CD process.

References:
https://docs.microsoft.com/en-us/azure/devops/articles/security-validation-cicd-pipeline?view=vsts

Create an Azure Resource Manager service connection with an existing service principal

AB: Enter the information about your service principal into the Azure subscription dialog textboxes:
1. Tenant ID
2. Subscription ID
3. Subscription name
4. Service principal ID
Either the service principal client key or, if you have selected Certificate, enter the contents of both the certificate and private key sections of the *.pem file.

If you're using the classic editor, select data you need. For example, the App service name.
If you're using YAML, then go to the resource in the Azure portal, and then copy the data into your code. For example, to deploy a web app, you would copy the name of the App Service into the WebAppName value.

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/library/connect-to-azure

Notifications help you and your team stay informed about activity that occurs within your projects in Azure DevOps. You can get notified when changes occur to the following items: work items code reviews pull requests source control files builds

References:
https://docs.microsoft.com/en-us/azure/devops/notifications/about-notifications?view=azure-devops

References:
https://learn.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core

Visual Studio Codespaces is built to accommodate the widest variety of projects or tasks, including GitHub and integrating debugging.

Visual Studio Codespaces conceptually and technically extends the Visual Studio Code Remote Development extensions.

In addition to "backend" environments, Visual Studio Codespaces supports these "frontend" editors: Visual Studio Code Visual Studio Code-based editor in the browser

References:
https://docs.microsoft.com/sv-se/visualstudio/codespaces/overview/what-is-vsonline

Step 1: Create a repository
A Git repository, or repo, is a folder that you've told Git to help you track file changes in.You can have any number of repos on your computer, each stored in their own folder.

Step 2: Create a branch Branch policies help teams protect their important branches of development. Policies enforce your team's code quality and change management standards.

Step 3: Add a build validation policy When a build validation policy is enabled, a new build is queued when a new pull request is created or when changes are pushed to an existing pull request targeting this branch. The build policy then evaluates the results of the build to determine whether the pull request can be completed.

Scenario:
Implement a code flow strategy for Project2 that will:
1. Enable Team2 to submit pull requests for Project2.
2. Enable Team2 to work independently on changes to a copy of Project2.
3. Ensure that any intermediary changes performed by Team2 on a copy of Project2 will be subject to the same restrictions as the ones defined in the build policy of Project2.

References:
https://docs.microsoft.com/en-us/azure/devops/repos/git/manage-yourbranches

References:
https://docs.microsoft.com/en-us/azure/azure-monitor/insights/azure-sql

Explanation:
Box 1: Modify ApplicationInsights.config
In ApplicationInsights.config, you can adjust several parameters in the AdaptiveSamplingTelemetryProcessor node. The figures shown are the default values:

<MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>

The target rate of logical operations that the adaptive algorithm aims to collect on each server host. If your web app runs on many hosts, reduce this value so as to remain within your target rate of traffic at the Application Insights portal.

<EvaluationInterval>00:00:15</EvaluationInterval>

The interval at which the current rate of telemetry is reevaluated. Evaluation is performed as a moving average. You might want to shorten this interval if your telemetry is liable to sudden bursts.

Etc.

Box 2: Modify the Usage and estimated costs settings.

Ingestion sampling
Use this type of sampling if your app often goes over its monthly quota and you don't have the option of using either of the SDK-based types of sampling.

Set the sampling rate in the Usage and estimated costs page:

Incorrect:
* Smart detection
Proactive diagnostics is a recent feature. Without any special configuration by you, Application Insights automatically detects and alerts you about unusual rises in failure rates in your app. It's smart enough to ignore a background of occasional failures, and also rises that are simply proportionate to a rise in requests. So for example, if there's a failure in one of the services you depend on, or if the new build you just deployed isn't working so well, then you'll know about it as soon as you look at your email. (And there are webhooks so that you can trigger other apps.)

Another aspect of this feature performs a daily in-depth analysis of your telemetry, looking for unusual patterns of performance that are hard to discover. For example, it can find slow performance associated with a particular geographical area, or with a particular browser version.

* Continuous Export
Want to keep your telemetry for longer than the standard retention period? Or process it in some specialized way? Continuous Export is ideal for this purpose. The events you see in the Application Insights portal can be exported to storage in Microsoft Azure in JSON format. From there, you can download your data and write whatever code you need to process it.

References:
https://docs.microsoft.com/en-us/azure/azure-monitor/app/sampling
https://docs.microsoft.com/en-us/azure/azure-monitor/app/devops#smart-detection

You can import an existing Git repo from GitHub, Bitbucket, GitLab, or other location into a new or empty existing repo in your project in Azure DevOps.

Import into a new repo
1. Select Repos, Files.
2. From the repo drop-down, select Import repository.
3. If the source repo is publicly available, just enter the clone URL of the source repository and a name for your new Git repository.

References:
https://docs.microsoft.com/en-us/azure/devops/repos/git/import-git-repository?view=azure-devops

Box 1: Reader
Members of a group named Developers must be able to install packages.

Feeds have four levels of access: Owners, Contributors, Collaborators, and Readers. Owners can add any type of identity-individuals, teams, and groups-to any access level.

Box 2: Owner
Members of a group named Team Leaders must be able to create new packages and edit the permissions of package feeds.

Webhooks provide a way to send a JSON representation of an event to any service. All that is required is a public endpoint (HTTP or HTTPS).

Q: Can I send webhooks to non HTTPS endpoints?
A: Yes. However, it's recommended that you only use HTTPS endpoints for your webhooks. Using HTTP means there is the potential for private data being sent unencrypted. This includes any authentication headers in your webhook.

References:
https://learn.microsoft.com/en-us/azure/devops/service-hooks/services/webhooks

References:
https://whitesource.atlassian.net/wiki/spaces/WD/pages/34209870/NPM+Plugin
https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json

User1: Project Administrators
You must have the permission Create Repository to publish code as wiki. By default, this permission is set for members of the Project Administrators group.

User2: Contributors
Anyone who is a member of the Contributors security group can add or edit wiki pages.

Anyone with access to the team project, including stakeholders, can view the wiki.

References:
https://docs.microsoft.com/en-us/azure/devops/project/wiki/wiki-create-repo

Manage flaky tests
Productivity for developers relies on the ability of tests to find real problems with the code under development or update in a timely and reliable fashion. Flaky tests present a barrier to finding real problems, since the failures often don't relate to the changes being tested. A flaky test is a test that provides different outcomes, such as pass or fail, even when there are no changes in the source code or execution environment. Flaky tests also impact the quality of shipped code.

The goal of bringing flaky test management in-product is to reduce developer pain cause by flaky tests and cater to the whole workflow. Flaky test management provides the following benefits.

Detection - Auto detection of flaky test with rerun or extensibility to plug in your own custom detection method

Management of flakiness - Once a test is marked as flaky, the data is available for all pipelines for that branch

Report on flaky tests - Ability to choose if you want to prevent build failures caused by flaky tests, or use the flaky tag only for troubleshooting

Resolution - Manual bug-creation or manual marking and unmarking test as flaky based on your analysis

Close the loop - Reset flaky test as a result of bug resolution / manual input

References:
https://learn.microsoft.com/en-us/azure/devops/pipelines/test/flaky-test-management

1. Within each team, users can create different channels to organize their communications by topic. Each channel can include a couple of users or scale to thousands of users.
2. Microsoft Teams works on Android, iOS, Mac and Windows systems and devices. It also works in Chrome, Firefox, Internet Explorer 11 and Microsoft Edge web browsers.
3. The guest-access feature in Microsoft Teams allows users to invite people outside their organizations to join internal channels for messaging, meetings and file sharing. This capability helps to facilitate business-to-business project management.
4. Teams integrates with Azure DevOps.

Note: Slack would also be a correct answer, but it is not an option here.

References:
https://searchunifiedcommunications.techtarget.com/definition/Microsoft-Teams

Explanation:
Repositories are resolved only once, when the pipeline starts up. After that, the same resource is used for the duration of the pipeline. Only the template files are used. Once the templates are fully expanded, the final pipeline runs as if it were defined entirely in the source repo. This means that you can't use scripts from the template repo in your pipeline.

If you want to use a particular, fixed version of the template, be sure to pin to a ref. The refs are either branches (refs/heads/<name>) or tags (refs/tags/<name>). If you want to pin a specific commit, first create a tag pointing to that commit, then pin to that tag.

NOTE: If no ref is specified, the pipeline will default to using refs/heads/main.

References:
https://github.com/MicrosoftDocs/azure-devops-docs/blob/main/docs/pipelines/process/templates.md

Register your application to use Azure Active Directory. Registering the application means that your developers can use Azure AD to authenticate users and request access to user resources such as email, calendar, and documents.

References:
https://docs.microsoft.com/en-us/azure/active-directory/manage-apps/developer-guidance-for-integrating-applications

References:
https://github.com/maartenba/myget-documentation/blob/master/how-to/working-with-upstream-package-sources.md

Question I need more hosted build resources. What can I do? Answer The Azure Pipelines pool provides all Azure DevOps organizations with cloud-hosted build agents and free build minutes each month. If you need more Microsoft-hosted build resources, or need to run more jobs in parallel, then you can either: Host your own agents on infrastructure that you manage.
Buy additional parallel jobs.

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/pools-queues

Explanation:
Pester is a testing and mocking framework for PowerShell.

Pester provides a framework for writing and running tests. Pester is most commonly used for writing unit and integration tests, but it is not limited to just that. It is also a base for tools that validate whole environments, computer deployments, database configurations and so on.

Example: Building a Continuous Integration and Continuous Deployment pipeline with DSC This example demonstrates how to build a Continuous Integration/Continuous Deployment (CI/CD) pipeline by using PowerShell, DSC, and Pester.

IntegrationTests: Runs the Pester integration tests.
UnitTests: Runs the Pester unit tests.

Incorrect:
* PSScriptAnalyzer
PSScriptAnalyzer is a static code checker for PowerShell modules and scripts. PSScriptAnalyzer checks the quality of PowerShell code by running a set of rules. The rules are based on PowerShell best practices identified by PowerShell Team and the community. It generates DiagnosticResults (errors and warnings) to inform users about potential code defects and suggests possible solutions for improvements.

PSScriptAnalyzer ships with a collection of built-in rules that check various aspects of PowerShell code such as:

The presence of uninitialized variables
Use of PSCredential type
Use of Invoke-Expression
And many more

References:
https://pester.dev/docs/quick-start/#what-is-pester
https://learn.microsoft.com/en-us/azure/devops/pipelines/release/dsc-cicd
https://github.com/PowerShell/PSScriptAnalyzer

Explanation:

Step 1: git log.
Find the commit SHA of the commit you want to revert to. To look through a log of commits, type git log.

Step 2: git checkout [hash]~1 --path/to/file
If you have deleted the file and already committed the changes, you need to use the `git checkout` command to restore the file. First, you need to find out the checksum of the commit that deleted the file, and then check out the file from the
previous commit.

This command tells `git` to list all commits, which can be reached from the HEAD, that changed the file `file1.txt`. The `-n 1` option tells `git` to limit the result to only one commit. The output is the checksum of the commit that deleted the file.

To undo changes on a single file or directory from commit B, but retain them in the staged state:

git checkout <commit-B-SHA> <file

Step 3: git restore path/to/file
To unstage the file but keep your changes:

git restore --staged <file>

Note: Recovering Deleted Files with the Command Line Recovering a deleted file using the Git command line involves the `git restore` or `git checkout`command. Whenever you modify files in Git-including creating new files, editing, or deleting existing files-the changes start as unstaged. Then you stage the changes with the `git add` command, and finally, you commit the changes using the `git commit` command. Git provides ways to recover a deleted file at any point in this life cycle of changes.

If you have not staged the deletion yet, simply run `git restore <filename>` and the file will be restored from the index.

References:
https://rewind.com/blog/recovering-deleted-files-in-github/
https://docs.gitlab.com/ee/topics/git/numerous_undo_possibilities_in_git/

Step 1: Kubectl create
You can add a service account to Tiller using the --service-account <NAME> flag while you're configuring Helm (step 2 below). As a prerequisite, you'll have to create a role binding which specifies a role and a service account name that have been set up in advance.
Example: Service account with cluster-admin role
$ kubectl create -f rbac-config.yaml
serviceaccount "tiller" created
clusterrolebinding "tiller" created
$ helm init --service-account tiller

Step 2: helm init
To deploy a basic Tiller into an AKS cluster, use the helm init command.

Step 3: helm install
To install charts with Helm, use the helm install command and specify the name of the chart to install.

References:
https://docs.microsoft.com/en-us/azure/aks/kubernetes-helm
https://docs.helm.sh/using_helm/#tiller-namespaces-and-rbac

Contributors have permissions to contribute fully to the project code base and work item tracking. The main permissions they don't have or those that manage or administer resources.

References:
https://docs.microsoft.com/en-us/azure/devops/organizations/security/permissions
https://docs.microsoft.com/en-us/azure/devops/organizations/security/permissions-access-work-tracking?view=azure-devops#queries-and-semantic-search

Box 1: Progressive exposure
Continuous Delivery may sequence multiple deployment "rings" for progressive exposure (also known as "controlling the blast radius"). Progressive exposure groups users who get to try new releases to monitor their experience in "rings." The first deployment ring is often a "canary" used to test new versions in production before a broader rollout. CD automates deployment from one ring to the next and may optionally depend on an approval step, in which a decision maker signs off on the changes electronically. CD may create an auditable record of the approval in order to satisfy regulatory procedures or other control objectives.

Box 2: Feature flags
Feature flags support a customer-first DevOps mindset, to enable (expose) and disable (hide) features in a solution, even before they are complete and ready for release.

Box 3: Blue/green
Blue/green deployments which means that instead of replacing the previous version (here we refer to this version as blue), we bring up the new version (here referred to as the green version) next to the existing version, but not expose it to the actual users right away. On the condition of having successfully validated that the green version works correctly, we will promote this version to the public version by changing the routing configuration without downtime. If something is wrong with the green version we can revert back without users every noticing interruptions.

References:
https://docs.microsoft.com/en-us/azure/devops/learn/what-is-continuous-delivery
https://docs.microsoft.com/en-us/azure/devops/migrate/phase-features-with-feature-flags
https://medium.com/@denniszielke/continuous-kubernetes-blue-green-deployments-on-azure-using-nginx-appgateway-or-trafficmanager-4490bce29cb

You can use the combination of Terraform and Yeoman. Terraform is a tool for creating infrastructure on Azure. Yeoman makes it easy to create Terraform modules.

Terratest provides a collection of helper functions and patterns for common infrastructure testing tasks, like making HTTP requests and using SSH to access a specific virtual machine. The following list describes some of the major advantages of using Terratest:
1. Convenient helpers to check infrastructure - This feature is useful when you want to verify your real infrastructure in the real environment.
2. Organized folder structure - Your test cases are organized clearly and follow the standard Terraform module folder structure.
3. Test cases are written in Go - Many developers who use Terraform are Go developers. If you're a Go developer, you don't have to learn another programming language to use Terratest.
4. Extensible infrastructure - You can extend additional functions on top of Terratest, including Azure-specific features.

References:
https://docs.microsoft.com/en-us/azure/developer/terraform/create-base-template-using-yeoman
https://docs.microsoft.com/en-us/azure/developer/terraform/test-modules-using-terratest

Explanation:

Box 1: clone
git-clone - Clone a repository into a new directory

Box 2: branch
--branch <name>
Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository's HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.

Incorrect:
* git pull

The git pull command is used to fetch and download content from a remote repository and immediately update the local repository to match that content.
SYNOPSIS git pull [<options>] [<repository> [<refspec>...]]

* git-add - Add file contents to the index

References:
https://git-scm.com/docs/git-clone
https://git-scm.com/docs/git-pull

You can manage technical debt with SonarQube and Azure DevOps.
Note: Technical debt is the set of problems in a development effort that make forward progress on customer value inefficient. Technical debt saps productivity by making code hard to understand, fragile, time-consuming to change, difficult to validate, and creates unplanned work that blocks progress. Unless they are managed, technical debt can accumulate and hurt the overall quality of the software and the productivity of the development team in the long term SonarQube an open source platform for continuous inspection of code quality to perform automatic reviews with static analysis of code to: Detect Bugs Code Smells Security Vulnerabilities Centralize Quality What's covered in this lab

References:
https://azuredevopslabs.com/labs/vstsextend/sonarqube/

Explanation:

Box 1: MAJOR
Semantic Versioning 2.0.0
Summary
Given a version number MAJOR.MINOR.PATCH, increment the:

MAJOR version when you make incompatible API changes

Note: Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.

Box 2: Minor
How should I handle deprecating functionality?
Deprecating existing functionality is a normal part of software development and is often required to make forward progress. When you deprecate part of your public API, you should do two things: (1) update your documentation to let users know about the change, (2) issue a new minor release with the deprecation in place. Before you completely remove the functionality in a new major release there should be at least one minor release that contains the deprecation so that users can smoothly transition to the new API.

Box 3: Minor
MINOR version when you add functionality in a backwards compatible manner

Incorrect:
* Patch PATCH version when you make backwards compatible bug fixes

References:
https://semver.org/

Scenario:

Step 1: Sign in to Azure Devops by using an account that is assigned the Administrator service connection security role.

Note: Under Agent Phase, click Deploy Service Fabric Application. Click Docker Settings and then click Configure Docker settings. In Registry Credentials Source, select Azure Resource Manager Service Connection. Then select your Azure subscription.

Step 2: Create a personal access token..
A personal access token or PAT is required so that a machine can join the pool created with the Agent Pools (read, manage) scope.

Step 3: Install and register the Azure Pipelines agent on an Azure virtual machine.
By running a Azure Pipeline agent in the cluster, we make it possible to test any service, regardless of type.

References:
https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-tutorial-deploy-container-app-with-cicd-vsts
https://mohitgoyal.co/2019/01/10/run-azure-devops-private-agents-in-kubernetes-clusters/

You can authenticate as a GitHub App.

References:
https://developer.github.com/apps/building-github-apps/authenticating-with-github-apps/

Explanation:
Step 1: Add the Firebase Crashlytics SDK to your app.
Configure the Firebase module: Import the Firebase module in your App struct or UIApplicationDelegate

References:
https://firebase.google.com/docs/crashlytics/get-started?platform=ios

You can use the combination of Terraform and Yeoman. Terraform is a tool for creating infrastructure on Azure. Yeoman makes it easy to create Terraform modules.

Terratest provides a collection of helper functions and patterns for common infrastructure testing tasks, like making HTTP requests and using SSH to access a specific virtual machine. The following list describes some of the major advantages of using Terratest:
1. Convenient helpers to check infrastructure - This feature is useful when you want to verify your real infrastructure in the real environment.
2. Organized folder structure - Your test cases are organized clearly and follow the standard Terraform module folder structure.
3. Test cases are written in Go - Many developers who use Terraform are Go developers. If you're a Go developer, you don't have to learn another programming language to use Terratest.
4. Extensible infrastructure - You can extend additional functions on top of Terratest, including Azure-specific features.

References:
https://docs.microsoft.com/en-us/azure/developer/terraform/create-base-template-using-yeoman
https://docs.microsoft.com/en-us/azure/developer/terraform/test-modules-using-terratest

Box 1: Readers
Project managers must only be able to view the repository.
Only read permission necessary.

Box 2: Project Administrators
The lead developer must be able to create repositories, manage permissions, manage policies, and contribute to the repository.
Add to the Project Collection Administrators security group users tasked with managing organization or collection resources.

Box 3: Contributors
Developers must be able to contribute to the repository and create branches, but NOT bypass policies when pushing builds.
Add to the Contributors security group full-time workers who contribute to the code base or manage projects.
References:
https://docs.microsoft.com/en-us/azure/devops/organizations/security/look-up-project-collection-administrators

References:
https://docs.microsoft.com/en-us/powershell/module/azurerm.automation/register-azurermautomationdscnode?view=azurermps-6.13.0

Instead use Octopus Tentacle.

References:
https://explore.emtecinc.com/blog/octopus-for-automated-deployment-in-devops-models

Instead you should deploy an Azure self-hosted agent to an on-premises server.

Note: To build your code or deploy your software using Azure Pipelines, you need at least one agent.

If your on-premises environments do not have connectivity to a Microsoft-hosted agent pool (which is typically the case due to intermediate firewalls), you'll need to manually configure a self-hosted agent on on-premises computer(s).

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/agents?view=azure-devops

Explanation:

Box 1: build.sh
Conditioning on cache restoration
In some scenarios, the successful restoration of the cache should cause a different set of steps to be run. For example, a step that installs dependencies can be skipped if the cache was restored. This is possible using the cacheHitVar task input. Setting this input to the name of an environment variable will cause the variable to be set to true when there's a cache hit, inexact on a restore key cache hit, otherwise it will be set to false. This variable can then be referenced in a step condition or from within a script.

In the following example, the install-deps.sh step is skipped when the cache is restored:

YAML

steps:
- task: Cache@2
inputs:
key: mykey | mylockfile
restoreKeys: mykey
path: $(Pipeline.Workspace)/mycache
cacheHitVar: CACHE_RESTORED

- script: install-deps.sh
condition: ne(variables.CACHE_RESTORED, 'true')

- script: build.sh

Box 2: ne(variables.CACHE_RESTORED, 'true')

Incorrect:
* always() condition: always() # this step will always run, even if the pipeline is canceled

* .integrationtest.sh
Build base images in integration tests.

* npm install npm install downloads a package and it's dependencies.
When run without arguments, npm install downloads dependencies defined in a package.json file and generates a node_modules folder with the installed modules.

References:
https://learn.microsoft.com/en-us/azure/devops/pipelines/release/caching

Gates allow automatic collection of health signals from external services, and then promote the release when all the signals are successful at the same time or stop the deployment on timeout. Typically, gates are used in connection with incident management, problem management, change management, monitoring, and external approval systems.

Approvals and gates give you additional control over the start and completion of the deployment pipeline. Each stage in a release pipeline can be configured with pre-deployment and post-deployment conditions that can include waiting for users to manually approve or reject deployments, and checking with other automated systems until specific conditions are verified.

References:
https://docs.microsoft.com/en-us/azure/devops/pipelines/release/approvals/gates

Box 1: Organization-level Administrator
The members of Group1 must be able to share and unshare a service connection with other projects.

Add members to the Project Collection Administrators group When you create an organization, you become a member of the Project Collection Administrators group. This group has the authority to manage the organization's settings, policies, and processes. It can also create and manage all the projects and extensions in the organization.

Incorrect:
* Project-level Administrators
Add members to the Project Administrators group
The person who creates a project is automatically added as a member to the Project Administrators group. Members of this group have permissions to manage project configuration, repositories, pipeline resources, teams, and all project-level permissions.

It's always a good idea to have more than one person who has administrative privileges. To add a user to this group, see Change permissions at the project level, Add members to the Project Administrators group.

Grant or restrict permissions Permissions are managed at the following three levels and through role-based assignments.

object
project
organization or collection
As a member of the Project Administrators group, you can grant or restrict permissions for all objects and at the project-level. To delegate specific tasks to others, we recommend that you add them to a built-in or custom security group, or add them to a specific role.

Box 2: Creator

The members of Group2 must be able to rename a service connection and update the description.

You can create, view, use, and manage a service connection based on your assigned user roles.
Role Creator
Members of this role can create the service connection in the project. Contributors are added as members by default

Box 3: User
The members of Group3 must be able to use the service connection within build or release pipelines.

Role User
Members of this role can use the service connection when authoring build or release pipelines or authorize yaml pipelines.

Note: User permissions on service connections

References:
https://learn.microsoft.com/en-us/azure/devops/user-guide/manage-organization-collection
https://learn.microsoft.com/en-us/azure/devops/pipelines/library/service-endpoints
https://learn.microsoft.com/en-us/azure/devops/user-guide/project-admin-tutorial

Step 1: Assign the node configuration.
You create a simple DSC configuration that ensures either the presence or absence of the Web-Server Windows Feature (IIS), depending on how you assign nodes.

Step 2: Upload a configuration to Azure Automation State Configuration.
You import the configuration into the Automation account.

Step 3: Compiling a configuration into a node configuration Compiling a configuration in Azure Automation Before you can apply a desired state to a node, a DSC configuration defining that state must be compiled into one or more node configurations (MOF document), and placed on the Automation DSC Pull Server.

Step 4: Onboard the virtual machines to Azure State Configuration Onboarding an Azure VM for management with Azure Automation State Configuration

Step 5: Check the compliance status of the node.
Viewing reports for managed nodes. Each time Azure Automation State Configuration performs a consistency check on a managed node, the node sends a status report back to the pull server. You can view these reports on the page for that node.

On the blade for an individual report, you can see the following status information for the corresponding consistency check: The report status - whether the node is "Compliant", the configuration "Failed", or the node is "Not Compliant" (when the node is in ApplyandMonitor mode and the machine is not in the desired state).

References:
https://docs.microsoft.com/en-us/azure/automation/automation-dsc-getting-started

You can use makelist to pivot data by the order of values in a particular column. For example, you may want to explore the most common order events take place on your machines. You can essentially pivot the data by the order of EventIDs on each machine.

Example:
Event
| where TimeGenerated > ago(12h)
| order by TimeGenerated desc
| summarize makelist(EventID) by Computer

References:
https://docs.microsoft.com/en-us/azure/azure-monitor/log-query/advanced-aggregations

References:
https://dzone.com/articles/fight-through-the-pain-how-to-deal-with-technical

You can use the Docker task to sign into ACR and then use a subsequent script to pull an image and scan the container image for vulnerabilities.
Use the docker task in a build or release pipeline. This task can be used with Docker or Azure Container registry.

Incorrect Answers:
C: We should not wait until deployment. We want to detect the exploits as early as possible.
D: We should wait until the image is in the product container. We want to detect the exploits as early as possible.

References:
https://docs.microsoft.com/en-us/azure/devops/articles/security-validation-cicd-pipeline?view=vsts