32,99 €
Mehr erfahren.
- Herausgeber: John Wiley & Sons
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
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.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 267
Veröffentlichungsjahr: 2023
Ähnliche
Table of Contents
COVER
TITLE PAGE
INTRODUCTION
WHO THIS BOOK IS FOR
CHAPTER OUTLINE
SUPPLEMENTAL MATERIALS
TO GET THE MOST OUT OF THIS BOOK
1 Introduction to DevOps
DEFINITION AND OVERVIEW OF DevOps
HISTORY OF DevOps
THE DevOps LIFE CYCLE
THE BENEFIT OF DevOps
THE CURRENT STATE OF DevOps
SUMMARY
2 Introduction to Azure DevOps
WHAT IS AZURE DevOps?
AZURE DevOps SERVICES VS. AZURE DevOps SERVER
AZURE DevOps FEATURES
BENEFITS OF AZURE DevOps
AZURE MONITOR
AZURE DevTest LABS
SUMMARY
3 Managing an Azure DevOps Project with Azure Boards
AZURE DevOps ORGANIZATIONS
PLANNING YOUR ORGANIZATION
CREATING AN AZURE DevOps ORGANIZATION
AZURE DevOps PROJECTS
CONCEPTS IN AZURE BOARDS
INTEGRATING AZURE BOARDS WITH GitHub
SUMMARY
4 Version Control with Azure Repos
VERSION CONTROL
GIT
PULL REQUESTS
GIT TAGS
SUMMARY
5 Automating Code Builds with Azure Pipelines
OVERVIEW OF CONTINUOUS INTEGRATION AND CONTINUOUS DEPLOYMENT
OVERVIEW OF AZURE PIPELINES
AZURE PIPELINES AGENTS AND AGENT POOLS
AZURE PIPELINES BUILD SCRIPT
SUMMARY
6 Running Automated Tests with Azure Pipelines
OVERVIEW OF SOFTWARE TESTING
TYPES OF SOFTWARE TESTS
STEPS FOR RUNNING SOFTWARE TESTS
SETTING UP TESTING IN AZURE PIPELINES
SUMMARY
7 Creating and Hosting Source Code Packages with Azure Artifacts
OVERVIEW OF ARTIFACT REPOSITORIES
INTRODUCTION TO AZURE ARTIFACTS
AZURE ARTIFACTS FEEDS
AZURE ARTIFACTS FEED VIEWS
UPSTREAM SOURCES
PUBLISHING ARTIFACTS IN AZURE PIPELINES
DOWNLOADING ARTIFACTS IN AZURE PIPELINES
SUMMARY
8 Automating Code Deployments with Azure Pipelines
CONTINUOUS DEPLOYMENT AND CONTINUOUS DELIVERY IN DevOps
RELEASE PIPELINES
MULTISTAGE PIPELINES
SUMMARY
9 Application Testing with Azure Test Plans
OVERVIEW OF AZURE TEST PLANS
CREATING TEST PLANS AND TEST SUITES
TEST CASES
CONFIGURATIONS IN TESTS
RUNNING MANUAL TESTS
RUNNING AUTOMATED TESTS FROM TEST PLANS
SUMMARY
10 Infrastructure Automation with Azure Pipelines
OVERVIEW OF INFRASTRUCTURE AUTOMATION
INFRASTRUCTURE AUTOMATION TOOLS ON AZURE
USING AZURE BICEP IN AZURE PIPELINES
SUMMARY
11 Exercise—Practice Using Azure DevOps Tools
INTRODUCING THE SAMPLE APPLICATION
IMPORTING THE REPOSITORY FROM GitHub TO AZURE REPOS
USING AZURE BOARDS TO MANAGE WORK ITEMS
COMMITTING CODE THAT ADDS NEW FEATURES
BUILDING THE CODE IN AZURE PIPELINES
DEPLOYING THE CODE
SUMMARY
12 Starting a Career in Azure DevOps
STARTING AN AZURE DevOps CAREER
GETTING YOUR FIRST JOB AS AN AZURE DevOps ENGINEER
FINDING AN AZURE DevOps COMMUNITY NEAR YOU
SUMMARY
13 Conclusion
APPENDIX: REVIEW QUESTIONS
CHAPTER 1
CHAPTER 2
CHAPTER 3
CHAPTER 4
CHAPTER 5
CHAPTER 6
CHAPTER 7
CHAPTER 8
CHAPTER 9
CHAPTER 10
CHAPTER 12
REFERENCES
DevOps, SITE RELIABILITY ENGINEERING, AND PLATFORM ENGINEERING
BOOKS
ARTICLES
AZURE DevOps SERVICES
BOOKS
ARTICLES
COMMUNITY FORUMS
INDEX
COPYRIGHT
ABOUT THE AUTHOR
ABOUT THE TECHNICAL EDITOR
ACKNOWLEDGMENTS
END USER LICENSE AGREEMENT
List of Illustrations
Chapter 1
FIGURE 1.1: The waterfall methodology
FIGURE 1.2: The DevOps life cycle
Chapter 3
FIGURE 3.1: Business units within a tech company
FIGURE 3.2: Business units represented as Azure DevOps organizations
FIGURE 3.3: Creating a new Azure DevOps organization
FIGURE 3.4: Naming the organization and specifying project location
FIGURE 3.5: Azure DevOps projects
FIGURE 3.6: Form to create your first Azure DevOps project
FIGURE 3.7: Azure DevOps project dashboard
FIGURE 3.8: Button for adding a new project to an organization
FIGURE 3.9: Form for adding a new project to an organization
FIGURE 3.10: Basic process
FIGURE 3.11: Agile process
FIGURE 3.12: Scrum process
FIGURE 3.13: CMMI process
FIGURE 3.14: Choosing a project process
FIGURE 3.15: Navigating to your work items
FIGURE 3.16: Work item types
FIGURE 3.17: New work item types
FIGURE 3.18: Specifying work items relationships
FIGURE 3.19: How to locate the Backlogs page
FIGURE 3.20: The Backlogs selection page
FIGURE 3.21: The Backlogs page showing a list of issues
FIGURE 3.22: Moving work item to iteration (or sprint)
FIGURE 3.23: Azure DevOps project board
FIGURE 3.24: Updating work item status
FIGURE 3.25: Dragging the work item from Doing to Done
FIGURE 3.26: Create task from issue work item
FIGURE 3.27: Sprint overview
FIGURE 3.28: Sprint taskboard
FIGURE 3.29: Navigating to the query dashboard
FIGURE 3.30: Creating a query
FIGURE 3.31: Query result
FIGURE 3.32: Azure Boards delivery plan
FIGURE 3.33: Project settings
FIGURE 3.34: Connecting to GitHub
FIGURE 3.35: Authorizing AzureBoards
FIGURE 3.36: Selecting the GitHub organization
FIGURE 3.37: Selecting the GitHub repositories
FIGURE 3.38: Approving, installing, and authorizing
FIGURE 3.39: GitHub connection confirmation
FIGURE 3.40: Adding a GitHub link to a work item
FIGURE 3.41: Linking the GitHub commit
FIGURE 3.42: Commit details
Chapter 4
FIGURE 4.1: Version control
FIGURE 4.2: Repository permissions dashboard
FIGURE 4.3: Types of permissions
FIGURE 4.4: Setting repository permissions
FIGURE 4.5: New repository dashboard
FIGURE 4.6: Clicking New Repository
FIGURE 4.7: Create repository form
FIGURE 4.8: New repository
FIGURE 4.9: Selecting the clone repository
FIGURE 4.10: Copying the clone URL
FIGURE 4.11: Selecting the import repository
FIGURE 4.12: Import repository form
FIGURE 4.13: Imported source code
FIGURE 4.14: Imported repository history
FIGURE 4.15: Creating a new pull request
FIGURE 4.16: New pull request details
FIGURE 4.17: Pull request prompt from Files page
FIGURE 4.18: Pull request prompt from Pull Requests page
FIGURE 4.19: Creating a pull request from a work item
FIGURE 4.20: Creating a draft pull request
FIGURE 4.21: Collaborating in pull requests
FIGURE 4.22: Creating a new tag
FIGURE 4.23: Creating tag form
FIGURE 4.24: List of tags
FIGURE 4.25: Creating a tag from commit
Chapter 5
FIGURE 5.1: Azure Pipelines flow
FIGURE 5.2: Create Pipeline button
FIGURE 5.3: Connecting a repository to your pipeline
FIGURE 5.4: Selecting a repository
FIGURE 5.5: Starter pipeline
FIGURE 5.6: Saving and running the YAML
FIGURE 5.7: Adding a commit message
FIGURE 5.8: Selecting existing YAML
FIGURE 5.9: Connecting to the classic editor
FIGURE 5.10: Classic editor template
FIGURE 5.11: Agent pools
FIGURE 5.12: Personal access token
FIGURE 5.13: Full-access PAT
FIGURE 5.14: Agent pool scope
FIGURE 5.15: Creating a new agent
FIGURE 5.16: Getting the agent window (Linux)
FIGURE 5.17: Getting the agent window (Windows)
FIGURE 5.18: Getting the agent window (macOS)
Chapter 6
FIGURE 6.1: Unit versus integration tests
FIGURE 6.2: Smoke tests
FIGURE 6.3: Choosing the classic editor
FIGURE 6.4: Selecting a pipeline source
FIGURE 6.5: Selecting pipeline templates
FIGURE 6.6: Selecting YAML (Default)
FIGURE 6.7: Build tasks
FIGURE 6.8: Running a pipeline form
FIGURE 6.9: Build and test results
Chapter 7
FIGURE 7.1: Azure DevOps dashboard
FIGURE 7.2: Create Feed button
FIGURE 7.3: Create New Feed window
FIGURE 7.4: Navigating to the feed settings
FIGURE 7.5: Feed Settings window
FIGURE 7.6: Adding an upstream source
FIGURE 7.7: Choosing an upstream source
FIGURE 7.8: List of upstream sources
FIGURE 7.9: Creating a feed with upstream sources
FIGURE 7.10: Navigating to the Feed settings
FIGURE 7.11: List of upstream sources
FIGURE 7.12: Adding an Azure Artifacts feed as an upstream source
FIGURE 7.13: Configuring the upstream source
FIGURE 7.14: Upstream sources from existing feed
FIGURE 7.15: Build pipeline
FIGURE 7.16: Classic editor
FIGURE 7.17: Adding a NuGet task to a pipeline
FIGURE 7.18: Creating a NuGet
pack
command
FIGURE 7.19: Creating a NuGet
push
command
FIGURE 7.20: Creating a Publish Pipeline Artifacts task
FIGURE 7.21: Creating a Download Pipeline Artifacts task
Chapter 8
FIGURE 8.1: How release pipelines work
FIGURE 8.2: Deployment models using Azure release pipelines
FIGURE 8.3: Creating a new release pipeline
FIGURE 8.4: Selecting a release pipeline template
FIGURE 8.5: Naming the deployment stage
FIGURE 8.6: Adding stage properties
FIGURE 8.7: Connecting an artifact to the release pipeline
FIGURE 8.8: Specifying artifact properties
FIGURE 8.9: Saving the release pipeline
FIGURE 8.10: Creating a release
FIGURE 8.11: Adding release properties
FIGURE 8.12: Release created successfully
FIGURE 8.13: New release details
FIGURE 8.14: New release details
FIGURE 8.15: Creating the first stage
FIGURE 8.16: Adding a new stage to the pipeline
FIGURE 8.17: Renaming the second stage
FIGURE 8.18: Adding properties for the second stage
FIGURE 8.19: Adding properties for the second stage
FIGURE 8.20: Predeployment conditions for staging
FIGURE 8.21: Setting deployment triggers
FIGURE 8.22: Staging now depends on Test
FIGURE 8.23: Predeployment approvals
FIGURE 8.24: Pipeline with three stages
Chapter 9
FIGURE 9.1: Navigating to Test Plans
FIGURE 9.2: Creating a new test plan
FIGURE 9.3: New test plan
FIGURE 9.4: Selecting Static Suite
FIGURE 9.5: New static test suite
FIGURE 9.6: Selecting Requirement Based Suite
FIGURE 9.7: Filter requirement
FIGURE 9.8: Creating the requirement-based suites
FIGURE 9.9: The requirement-based suites
FIGURE 9.10: Selecting a Query Based Suite
FIGURE 9.11: Query work items
FIGURE 9.12: Creating a query-based suite
FIGURE 9.13: Structure of test plans, test suites, and test cases
FIGURE 9.14: Structure of test plans and test cases
FIGURE 9.15: Click New Test Case
FIGURE 9.16: Test case form
FIGURE 9.17: Test cases
FIGURE 9.18: Creating a new configuration variable
FIGURE 9.19: Adding a configuration variable
FIGURE 9.20: New configuration
FIGURE 9.21: Adding a configuration
FIGURE 9.22: Assigning configurations
FIGURE 9.23: Selecting the previous configuration we created
FIGURE 9.24: Verifying the assigned configurations
FIGURE 9.25: Selecting a manual test
FIGURE 9.26: Test runner window
FIGURE 9.27: Selecting New Test Result Chart
FIGURE 9.28: Test result chart
FIGURE 9.29: Selecting Test Plan Settings
FIGURE 9.30: Test plans settings
FIGURE 9.31: Release pipeline for test plans
FIGURE 9.32: Test plan settings (with release pipeline details)
FIGURE 9.33: Selecting automated tests to run
FIGURE 9.34: Running automated tests
Chapter 10
FIGURE 10.1: How Azure Bicep works
FIGURE 10.2: Navigating to new service connection
FIGURE 10.3: New Service Connection pop-up
FIGURE 10.4: Choosing an authentication method
FIGURE 10.5: Service connection details
FIGURE 10.6: Creating a new pipeline
FIGURE 10.7: Configuring your pipeline
FIGURE 10.8: Deployment pipeline YAML file
FIGURE 10.9: Verifying your deployment
Chapter 11
FIGURE 11.1: Forking the project
FIGURE 11.2: Create fork form
FIGURE 11.3: Cloning a project
FIGURE 11.4: Importing a repository
FIGURE 11.5: Import repository wizard
FIGURE 11.6: Azure Repos project
FIGURE 11.7: Azure Boards
Chapter 12
FIGURE 12.1: Sample GitHub search results for Azure Pipelines topics
Guide
Cover
Title Page
Copyright
About the Author
About the Technical Editor
Acknowledgments
Introduction
Table of Contents
Begin Reading
Appendix: Areview Questions
References
Index
End User License Agreement
Pages
v
xix
xx
xxi
1
2
3
4
5
6
7
9
10
11
12
13
14
15
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
213
214
215
216
217
219
220
221
222
223
224
225
226
227
vi
vii
ix
xi
228
BEGINNINGAzure® DevOps
PLANNING, BUILDING, TESTING, AND RELEASING SOFTWARE APPLICATIONS ON AZURE
Adora Nwodo
INTRODUCTION
AS ORGANIZATIONS STRIVE FOR GREATER AGILITY AND EFFICIENCY in their software development and deployment processes, DevOps has grown in significance for software engineering teams. DevOps aims to automate the software delivery process from development to production by bringing together the teams responsible for development and operations. With this strategy, teams can deliver high-quality software to customers quickly and effectively while lowering the likelihood of mistakes and downtime. The advantages of DevOps have contributed to its quick rise in popularity in recent years as businesses look to boost productivity and boost customer satisfaction in order to remain competitive in today's fast-paced business environment.
Azure DevOps is a collection of tools and services offered by Microsoft to aid software development teams in the planning, collaboration, development, testing, and deployment of applications. It includes different tools that work together to provide a complete solution, such as Azure Boards for agile planning and tracking, Azure Repos for source code management and reviews, Azure Test Plans for testing, Azure Artifacts for managing and sharing packages, and Azure Pipelines for continuous integration and deployment. These tools can also be integrated with other Azure services to offer an end-to-end solution. It is designed to cater to the diverse needs of different teams and organizations, making it a widely used choice for software development teams.
Beginning Azure® DevOps starts with an overview of the concept of DevOps and then also covers an overview of Azure DevOps before diving into the various Azure DevOps services. By the end of this book, you will have a solid understanding of how to use Azure DevOps to improve your software development life cycle and will be equipped with the knowledge and skills to implement it in your own organization. You will also learn a few tips that can help you start and grow your DevOps career using Azure DevOps tools.
WHO THIS BOOK IS FOR
This book is intended for a wide range of readers, including those without any prior experience in DevOps who want to build a career in it, as well as early to mid-career software engineers, platform engineers, site reliability engineers, and other DevOps professionals looking to improve their skills. Additionally, solution architects and product/project managers who want to use DevOps techniques and Azure DevOps to manage their software development process will find it useful. The book covers the concepts and tools of DevOps and how to use Azure DevOps throughout the software development cycle. It is suitable for readers of all levels, from beginners to those with some experience, and will provide them with the knowledge and skills needed to excel in their DevOps career and deliver high-quality software.
CHAPTER OUTLINE
Chapter 1, “Introduction to DevOps,” provides an overview of DevOps including its definition, history, the DevOps life cycle, benefits, and the current state of DevOps in the industry. It also covers the basics of DevOps, including its advantages and how it can be implemented to improve the software development process.
Chapter 2, “Introduction to Azure DevOps,” provides an overview of Azure DevOps, its features, benefits, and services such as Azure Boards, Azure Repos, Azure Pipelines, Azure Test Plans, and Azure Artifacts. It highlights the benefits of using Azure DevOps for improved collaboration and faster software delivery and also covers the difference between Azure DevOps Services and Azure DevOps Server.
Chapter 3, “Managing an Azure DevOps Project with Azure Boards,” explains what Azure DevOps organizations are and how to plan and create them. It also explains the concepts of Azure DevOps projects, including different types of projects and how to create them. It covers Azure Boards concepts such as work items, backlogs, boards, sprints, queries, and plans. The chapter also demonstrates how to integrate Azure Boards with GitHub.
Chapter 4, “Version Control with Azure Repos,” covers the topic of version control and its benefits, as well as Git, a popular version control system. It explains how to create and import Git repositories on Azure DevOps and covers the concept of pull requests and how to use them. It also explains how to use Git tags.
Chapter 5, “Automating Code Builds with Azure Pipelines,” provides an overview of CI/CD and how Azure Pipelines can be used in this process. It covers the features of Azure Pipelines and how to define and set up pipelines. The chapter also describes the components of Azure Pipelines and explains the concepts of agents and agent pools. It covers the different types of agents that can be used and the use of Azure Pipelines Build Scripts including YAML and how to write a build script.
Chapter 6, “Running Automated Tests with Azure Pipelines,” provides an overview of software testing, including its history and importance in the software development process. It covers different types of software tests, such as unit tests, integration tests, smoke tests, regression tests, and end-to-end tests. The chapter also explains the steps for running software tests and how to set up testing in Azure Pipelines, helping readers understand the importance of software testing and how to effectively test their software using Azure Pipelines.
Chapter 7, “Creating and Hosting Source Code Packages with Azure Artifacts,” provides an overview of artifact repositories and introduces Azure Artifacts as a tool for securely storing and managing artifacts during software development. It covers Azure Artifact feeds, including the different types of scopes available and how to create them. The chapter also describes Azure Artifact feed views and upstream sources and how to set them up. It also includes information on how to publish and download artifacts in Azure Pipelines.
Chapter 8, “Automating Code Deployments with Azure Pipelines,” covers release pipelines and how they work in Azure. It describes the deployment model using Azure Release Pipelines and shows how to create a release pipeline, create a release, and use multistage pipelines. The chapter also explains what multistage pipelines are and how to create them in Azure Release Pipelines.
Chapter 9, “Application Testing with Azure Test Plans,” provides an overview of the process of using Azure Test Plans for testing and managing the quality of software applications.
Chapter 10, “Infrastructure Automation with Azure Pipelines,” provides an overview on how to automate the provisioning and management of your application's infrastructure using tools like Azure Resource Manager templates and Azure Bicep and the benefits of using infrastructure as code. It also covers how to use Azure Bicep in Azure Pipelines, including setting up the tool, creating templates, and deploying them using the pipeline, with an emphasis on pipeline authentication.
Chapter 11, “Exercise: Practice Using Azure DevOps Tools,” introduces a sample project with different exercises that will enable the reader to practice the various Azure DevOps Tools and Services you have learned.
Chapter 12, “Starting a Career in Azure DevOps,” provides an overview of how to start a career in Azure DevOps. It includes tips on how to find your first job as an Azure DevOps engineer, as well as the importance of finding a community to support your professional development. The chapter aims to provide guidance on the skills and qualifications needed to succeed in this field.
Chapter 13, “Conclusion,” summarizes all you have learned in this book.
SUPPLEMENTAL MATERIALS
Additional content is available to all readers of this book at github.com/AdoraNwodo/SampleLibraryApp. This includes a sample project that can be used as a hands-on learning tool to help readers gain practical experience with the Azure DevOps tools discussed in the book. This sample project can be used to help readers understand the concepts and techniques covered in the book and to help them gain the skills and confidence needed to apply these tools in real-world scenarios.
TO GET THE MOST OUT OF THIS BOOK
One major prerequisite for the book is that you have an Azure account so that you can follow through with all the steps illustrated in the different chapters. The process of creating an Azure account can be completed in a few simple steps. Visit the Azure website at azure.com, click the Try Azure for Free button, and follow the steps.
1Introduction 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 feedback from customers and learn from that experience.
Better quality products:
In multiple stages of the DevOps life cycle, DevOps tools trigger and run automated tests. The presence of testing reduces the number of bugs that get to production environments when the code is deployed.
Accountability:
In the planning phase in the DevOps life cycle, team members simplify processes, enumerate different tasks for product development, and assign all the created tasks to different people to work on. The culture of accountability is built because of this process. With this model, everyone knows what they should work on and their task is building quality software and deploying their changes on time.
Easier rollbacks:
