Produkt

KlappentextThe 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.

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.

Details

Weitere ISBN/GTIN9781394165896

ProduktartE-Book

EinbandartE-Book

FormatEPUB

Format HinweisePub Wasserzeichen

FormatFormat mit automatischem Seitenumbruch (reflowable)

Verlag

John Wiley & Sons

Erscheinungsjahr2023

Erscheinungsdatum31.03.2023

Auflage1. Auflage

SpracheEnglisch

Artikel-Nr.11410551

Rubriken

Genre9201

Inhalt/Kritik

Inhaltsverzeichnis

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 219mehr

Leseprobe

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...
mehr

Autor

Nwodo, Adora

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.

Bitte warten - die Druckansicht der Seite wird vorbereitet.

Beginning Azure DevOps

Verfügbare Formate

Produkt

Inhalt/Kritik

Autor

Confident Cloud

Confident Cloud

Services

Infos

Über uns

Leistungen

Newsletter

Zahlung