
Beginning Azure DevOps
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
The perfect DevOps guide for beginning Azure users
In Beginning Azure DevOps: Planning, Building, Testing and Releasing Software Applications on Azure, award-winning software engineer Adora Nwodo delivers a beginner's guide to DevOps on the Microsoft-powered Azure cloud platform. In the book, you'll learn to deploy Azure's built-in DevOps tools required to plan, build, test, and ship applications.
The author explains how to use Azure's functionality for project management, version control, code testing, and continuous integration and continuous delivery (CI/CD). She discusses how to plan software development projects from start to finish using Agile and Scrum techniques. Readers will also find:
- Updated source code repositories on GitHub with instructive practice exercises
- Strategies for improving collaboration and automating your code-to-cloud workflows
- Techniques for securing your code with advanced capabilities
An essential resource for Azure novices who hope to learn about the myriad possibilities unlocked by Azure DevOps tools, Beginning Azure DevOps will also earn a place in the libraries of software professionals familiar with other cloud platforms who hope to gain a foothold in the Azure cloud environment.
More details
Other editions
Additional editions

Person
ADORA NWODO is an award-winning software engineer who develops mixed-reality products on the Azure cloud at Microsoft. She regularly publishes tech and career content on her blog and YouTube channel, where she teaches her community about software, infrastructure, and cloud engineering. She is a sought-after public speaker, tech community leader, and is the author of the self-published, Cloud Engineering for Beginners.
Content
Introduction xix
Chapter 1: Introduction to Devops 1
Definition and Overview of DevOps 1
History of DevOps 2
The DevOps Life Cycle 3
The Benefit of DevOps 4
The Current State of DevOps 5
Summary 7
Chapter 2: Introduction to Azure Devops 9
What Is Azure DevOps? 9
Azure DevOps Services vs. Azure DevOps Server 10
Differences Between Azure DevOps Services and Azure DevOps Server 10
Scoping 10
Authentication 11
Users and Group 11
User Access Management 11
Data Protection 12
Similarities Between Azure DevOps Services and Azure DevOps Server 12
Features 12
Analytics and Reporting 12
Process Customization 12
Added Benefits on Azure DevOps Services 12
Azure DevOps Features 13
Benefits of Azure DevOps 14
Azure Monitor 14
Azure DevTest Labs 15
Summary 15
Chapter 3: Managing an Azure Devops Project With Azure Boards 17
Azure DevOps Organizations 18
Planning Your Organization 18
Creating an Azure DevOps Organization 19
Azure DevOps Projects 20
Types of Projects 22
Single Project 22
Many Projects 22
Creating an Azure DevOps Project 22
Understanding Project Processes 24
Concepts in Azure Boards 27
Work Items 27
Creating a Work Item 28
Backlogs 31
Managing Backlogs 32
Boards 34
Sprints 36
Queries 37
Plans 39
Integrating Azure Boards with GitHub 40
GitHub and Azure Boards Connection 40
GitHub and Azure Boards Verification 44
Summary 45
Chapter 4: Version Control with Azure Repos 47
Version Control 48
Version Control Systems 48
History of Version Control 49
Benefits of Version Control 50
Git 50
What Is a Git Repository? 51
Create a Git Repository on Azure DevOps 51
Setting Repository Permissions 51
Creating the Repository 53
Cloning the Repository 55
Import an Existing Git Repository to Azure DevOps 57
Pull Requests 58
Draft Pull Requests 58
Create a Pull Request from Azure Repos 59
Creating a Pull Request from the Pull Requests Page 59
Creating a Pull Request from a Feature Branch 60
Creating a Pull Request from a Work Item in Azure Boards 60
Creating a Draft Pull Request 62
Collaborate in Pull Requests 63
Git Tags 63
Annotated Tags 63
Lightweight Tags 64
Create Tags in Azure DevOps 64
Using the Tags View 64
Using the Commits View 65
Summary 66
Chapter 5: Automating Code Builds with Azure Pipelines 67
Overview of Continuous Integration and Continuous Deployment 68
Continuous Integration 68
Continuous Deployment 68
Continuous Delivery 69
Overview of Azure Pipelines 69
Azure Pipelines Features 69
Defining Pipelines 69
Defining Pipelines Using YAML 71
Defining Pipelines Using the Classic Editor 74
Components of Azure Pipelines 76
Azure Pipelines Agents and Agent Pools 77
Agents 77
Agent Pools 77
Using Microsoft- Hosted Agents 78
Using Self- Hosted Linux Agents 79
Using Self- Hosted Windows Agents 81
Using Self- Hosted macOS Agents 82
Azure Pipelines Build Script 83
YAML Overview 83
Writing a Build Script 84
Summary 86
Chapter 6: Running Automated Tests with Azure Pipelines 89
Overview of Software Testing 90
History of Software Testing 90
Continuous Testing 90
Importance of Software Testing 91
Types of Software Tests 92
Unit Tests 92
Integration Tests 92
Smoke Tests 94
Regression Tests 94
End- to- End Tests 95
Other Types of Software Tests 96
Steps for Running Software Tests 96
Setting Up Testing in Azure Pipelines 97
Summary 102
Chapter 7: Creating and Hosting Source Code Packages with Azure Artifacts 103
Overview of Artifact Repositories 104
Introduction to Azure Artifacts 104
Azure Artifacts Feeds 105
Project- Scoped Feeds 105
Organization- Scoped Feeds 105
How to Create an Azure Artifacts Feed 106
Public Feeds 108
Azure Artifacts Feed Views 108
Types of Azure Artifacts Feed Views 108
Upstream Sources 108
Setting Up Upstream Sources 109
How to Update a Feed to Use an Upstream Source 109
How to Create a Feed with Upstream Source Capability 111
How to Add a Feed in Your Organization to an Upstream Source 113
Publishing Artifacts in Azure Pipelines 115
Publishing Artifacts Using the publish Keyword in YAML 115
Publishing Artifacts Using a YAML Task 115
Publishing Artifacts Using the Classic Editor 116
Downloading Artifacts in Azure Pipelines 120
Downloading Artifacts Using the Download Keyword in YAML 120
Downloading Artifacts Using a YAML Task 121
Downloading Artifacts Using the Classic Editor 121
Summary 122
Chapter 8: Automating Code Deployments With Azure Pipelines 125
Continuous Deployment and Continuous Delivery in DevOps 125
Continuous Deployment 126
Continuous Deployment Tools 126
Advantages of Continuous Deployment 127
Continuous Delivery 127
Advantages of Continuous Delivery 128
Release Pipelines 128
Advantages of Release Pipelines 129
How Release Pipelines Work in Azure 129
Deployment Model Using Azure Release Pipelines 131
Creating the Release Pipeline 131
Creating a Release 134
Multistage Pipelines 137
Summary 143
Chapter 9: Application Testing with Azure Test Plans 145
Overview of Azure Test Plans 146
How Azure Test Plans Work 146
Advantages of Azure Test Plans 147
Creating Test Plans and Test Suites 148
Test Plans 148
Test Suites 150
Adding a Static Test Suite 150
Adding a Requirement- Based Test Suite 151
Adding a Query- Based Test Suite 152
Test Cases 154
Overview of Test Cases 154
Creating Test Cases 154
Configurations in Tests 157
Creating Test Configurations 157
Assigning Test Configurations 159
Running Manual Tests 161
Running Tests with Configurations 161
Viewing Manual Test Results 161
Running Automated Tests from Test Plans 162
Setting Up Your Environment for Automated Tests 163
Running the Tests 164
Summary 166
Chapter 10: Infrastructure Automation with Azure Pipelines 169
Overview of Infrastructure Automation 169
Types of Infrastructure as Code 170
Imperative Infrastructure as Code 171
Declarative Infrastructure as Code 172
Benefits of Infrastructure as Code 173
Infrastructure Automation Tools on Azure 174
Azure Resource Manager Templates 174
Azure Bicep 176
How Azure Bicep Works 176
Benefits of Azure Bicep 177
Using Azure Bicep in Azure Pipelines 177
Setting Up Azure Bicep on Your Computer 177
Azure Bicep Templates Overview 178
Azure Bicep Templates in Azure Pipelines 179
Pipeline Authentication 179
Deploying Azure Bicep Templates Using the Pipeline 181
Summary 185
Chapter 11: Exercise- Practice Using Azure Devops Tools 187
Introducing the Sample Application 187
Create a Fork of the Project 188
Clone Your Fork Locally 189
Importing the Repository from GitHub to Azure Repos 189
Using Azure Boards to Manage Work Items 191
Committing Code That Adds New Features 193
Building the Code in Azure Pipelines 194
Deploying the Code 195
Summary 196
Chapter 12: Starting a Career in Azure Devops 197
Starting an Azure DevOps Career 197
Getting Your First Job as an Azure DevOps Engineer 199
Finding an Azure DevOps Community Near You 201
Summary 202
Chapter 13: Conclusion 203
Appendix: Review Questions 205
References 213
Index 219
1
Introduction to DevOps
"It is through improving our ability to deliver software that organizations can deliver features faster, pivot when needed, respond to compliance and security changes, and take advantage of fast feedback to attract new customers and delight existing ones."
-Nicole Forsgren, PhD
What You Will Learn in This Chapter
- Definition and Overview of DevOps
- History of DevOps
- The DevOps Life Cycle
- The Benefits of DevOps
- The Current State of DevOps
- Summary
How do we build secure, resilient, and rapidly evolving systems at scale? This was the question that led to the birth of DevOps. Prior to DevOps, this was an important problem that organizations were facing. As time passed, software engineering evolved, and more innovative software has been built to provide solutions in interesting business sectors. This software is currently transforming and accelerating different kinds of organizations.
DEFINITION AND OVERVIEW OF DevOps
DevOps is a culture or a set of practices bridging the gap between two formerly siloed units, software developers (Dev) and IT operations staff (Ops), throughout the entire product development life cycle. The adoption of the DevOps culture, tools, and applications has empowered teams with the ability to build and securely scale their software development practices, engage customers to get feedback more efficiently, and ship software that helps organizations meet their business goals faster.
HISTORY OF DevOps
To appreciate where DevOps is today, we should learn what existed before it. The DevOps trend was born in 2007. Prior to that, software developers wrote their code and worked differently from the other IT professionals who tested and deployed the code. This meant that there was a huge disconnect in software development and deployment practices.
One of the major factors for this was that software developers and IT professionals had different goals within an organization. The software developers only wanted to write code for software, and the IT/Ops professionals deployed the code when it was time. This made the product feature release timeline really long; a software development team would work on a feature for months before handing it over to the IT/Ops team for deployment. The IT/Ops team would also take some time to deploy the large feature that was introduced to the application. This created room for software bugs, slow deployments, and unstable applications. Over time, releasing software of poor standards would affect the experience of any customer using the application.
Prior to DevOps, the waterfall methodology was largely used. This methodology illustrates software development processes in a sequential manner. This means each process must be completed before the next process starts. Figure 1.1 illustrates the waterfall methodology.
During this time, requirements were gathered and planning was done before any system architecture, design, or coding commenced. Once the software design was validated, programmers would start writing the code required to build that software. After software development was completed, software testing commenced, and deployment of the large application followed. Maintenance happens when the application is now live in production, and that is done in its own silo.
With this model, no version of the application gets deployed until late in the cycle, which means months of working without seeing tangible results. If requirements also change halfway through the project, the entire plan is destabilized, and the team might have to end the project and start again. In the early 2000s, as software engineering evolved and quick innovation became an organizational advantage, organizations started adopting the agile methodology for building software because it was iterative and more flexible for long-term innovative projects.
The agile methodology is an iterative way to build software applications. This model involves a continuous loop of planning, implementation, testing, and feedback in short cycles. With the agile methodology, organizations could now deliver value quickly to their customers. However, as time went on and the agile methodology became the standard for project management and software development, innovation was still moving fast, and the desire to automate processes and iterate faster came to the limelight. This was how DevOps came to exist.
FIGURE 1.1: The waterfall methodology
THE DevOps LIFE CYCLE
With the DevOps life cycle, software development and IT/Ops teams are no longer siloed. The different steps integrate well with one another into stages for a broader and more cohesive engineering team. The stages are continuous, and the output of a stage is usually the input of the next stage. The stages are as follows:
- Planning: The planning phase involves teams identifying business requirements and then itemizing and strategizing for the different features of the application currently being built. This is an important stage in the management of the project. Here, the product teams also create a product roadmap and continuously track the progress of this task so that they can incrementally deliver and maximize value across the team.
- Development: During development, the teams work on different tasks created in the planning stage. This work involves writing the source code for the software feature. At this stage, different software developers are able to work on the same codebase simultaneously because of the integration of some DevOps tools that make this possible.
- Continuous integration: This stage commences when the software developers writing code integrate their own changes to the existing repository or codebase. This integration involves testing the code, merging the code to the larger repository, and creating build artifacts or executables that would be used during deployment.
- Deployment: In this stage, the output from the build step is deployed to different production environments across multiple geographic locations. Apart from source code deployment, application infrastructure can also be deployed in this step. This infrastructure is a foundational piece and the environment that the source code would run on.
For this deployment phase to be effective and secure, software development teams set up approvals and access policies for these production environments. This is important to control the deployments moving to production and anticipate the results of different deployments. This way, teams can automate code deployments with ease and confidence.
- Monitoring and operating: At this stage, a new version of software has been released to production and is currently in use by customers. The software development teams can now monitor user behavior, application performance, and other metrics. This monitoring helps teams improve the application so that they can always provide software with high availability to their customers.
With monitoring, software development teams can spot performance bottlenecks in real time and come up with solutions. If there is an error in the application, team members debug and troubleshoot until they can mitigate or resolve the problem.
- Feedback: User feedback is how teams improve on software. This involves communicating with customers to learn about their experiences using the software application. The output of the feedback process can be feature requests or application improvements. This output is usually the input for the planning phase of the next DevOps life cycle iteration (Figure 1.2).
FIGURE 1.2: The DevOps life cycle
THE BENEFIT OF DevOps
The main goal of the DevOps culture is automation. The ability to automate different stages in the product development life cycle that were initially manual has the following benefits:
- Speed: As more tech companies come into the limelight, speed has become an important factor in innovating and keeping customers satisfied. DevOps makes speed possible. Teams can now build and release stable software in a timely manner due to automation.
- Shorter release cycles: DevOps teams implement the agile methodology. The agile methodology is an iterative software development methodology that allows teams to update software in bits, learn from that experience, and improve in the next software update iteration. Because of this, teams are not waiting to build out the entire application for as long as 18 months. Features can be iteratively worked on during short cycles called sprints; these cycles make code releases and debugging easier.
- Collaboration: DevOps fosters collaboration within teams. This culture eliminates the siloed approach to software development that once existed and makes it possible for team members with different skill sets (e.g., software developers, product managers, QA testers, site reliability engineers, etc.) to work cohesively together toward the launch of a product or feature.
- Learning: When software is released, monitoring starts. Here, teams are able to learn about the performance of their application and correct their mistakes to build better and faster software that their customers would enjoy. The DevOps model makes learning possible in the monitoring and feedback phase. Teams can learn from data obtained from logs, metrics, and traces. Teams can also take...
System requirements
File format: ePUB
Copy protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (not Kindle).
The file format ePub works well for novels and non-fiction books – i.e., „flowing” text without complex layout. On an e-reader or smartphone, line and page breaks automatically adjust to fit the small displays.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our ebook Help page.