DevOps For Dummies

Understanding the Adoption Curve 51
Pushing for change 54
Responding to pushback 55
Navigating the chasm 56
Asking “Why?” 56

Chapter 5: Measuring Your Organization 59
Measuring Your Progress 59
Quantifying DevOps 61
Collecting the data 64
Developing internal case studies 66

Part 2: Establishing a Pipeline 69
Chapter 6: Embracing the New Development Life Cycle 71
Inviting Everyone to the Table 72
Changing Processes: From a Line to a Circuit 73
Shifting Ops “Left”: Thinking about Infrastructure 77
Shifting deployments left, too 78
Mimicking production through staging 78

Chapter 7: Planning Ahead 79
Moving beyond the Agile Model 80
Forecasting Challenges 81
Identifying project challenges and constraints 82
Gathering Requirements 84
Designing an MVP 85
Discovering the problem for your MVP to solve 86
Identifying your customer 86
Scrutinizing the competition 87
Prioritizing features 87
Designing the user experience 88
Testing your hypothesis 89
To beta or not to beta? 90
Determining Your Customer by Designing a Persona 91
What is a persona? 91
Designing a persona 92

Chapter 8: Designing Features from a DevOps Perspective 95
Constructing Your Design 96
Designing for DevOps 99
Designing software for change 99
Improving software constantly 100
Documenting your software 101
Architecting Code for the Six Capabilities of DevOps 102
Maintainability 103
Scalability 103
Security 105
Usability 106
Reliability 107
Flexibility 108
Documenting Design Decisions 108
Avoiding Architecture Pitfalls 109

Chapter 9: Developing Code 111
Communicating about Code 111
Engineering for Error 114
Writing Maintainable Code 114
Testing code 115
Debugging code 115
Logging code 116
Writing immutable code 117
Creating readable code 117
Programming Patterns 117
Object-oriented programming 117
Functional programming 118
Choosing a Language 119
Avoiding Anti-Patterns 119
DevOpsing Development 121
Writing clean code 121
Understanding the business 122
Listening to others 122
Focusing on the right things 122
Getting comfortable with being uncomfortable 123
Establishing Good Practices 124
Organizing your source code 124
Writing tests 124
Documenting features 125
Having peers review your code 126

Chapter 10: Automating Tests Prior to Release 129
Testing Isn’t Optional 129
Automating Your Testing 130
Testing in Different Environments 131
Local environment 132
Development environment 133
Testing environment 133
Staging environment 134
Production environment 135
Going beyond the Unit Test 135
Unit tests: It’s alive! 136
Integration tests: Do all the pieces work together? 136
Regression tests: After changes, does the code behave the same? 137
Visual tests: Does everything look the same? 137
Performance testing 137
Continuous Testing 138

Chapter 11: Deploying a Product 139
Releasing Code 139
Integrating and Delivering Continuously 140
Benefitting from CI/CD 141
Implementing CI/CD 141
Managing Deployments 143
Automating the right way 143
Versioning 144
Mitigating Failure 146
Rolling back 146
Fixing forward 147
Democratizing Deployments 147
Choosing a Deployment Style 148
Blue-green: Not just for lakes 149
Schrodinger’s canary: The deploy’s not dead (or is it?) 150
Rolling the dice 152
Toggling with feature flags 153
Monitoring Your Systems 154
Understanding telemetry 154
Recording behavior 155
SLAs, SLIs, and SLOs 156

Part 3: Connecting the Circuit 159
Chapter 12: Implementing Rapid Iteration 161
Prioritizing the Important 162
Important and urgent 163
Important, not urgent 164
Urgent, not important 166
Neither important nor urgent 167
Increasing Velocity 167
Improving Performance 171
Eliminating perfection 172
Designing small teams 172
Tracking your work 173
Reducing friction 173
Humanizing alerting 174

Chapter 13: Creating Feedback Loops around the Customer 175
Creating a Customer Feedback Process 176
Creating a Feedback Loop 177
Receive 177
Analyze 178
Communicate 179
Change 179
Collecting Feedback 180
Satisfaction surveys 180
Case studies 181
Dogfooding 182
Asking for Continual Feedback 184
Net promoter score (NPS) 185
Finding a rhythm 185

Chapter 14: DevOps Isn’t a Team (Except When It Is) 189
Forming DevOps Teams 189
Aligning functional teams 190
Dedicating a DevOps team 191
Creating cross-functional product teams 192
Interviewing Quickly (But Not Too Quickly) 194
Deciding on a Job Title 195
Recruiting Never Ends 197
Finding the right folks 198
Passing along great candidates 199
Evaluating Technical Ability 199
Whiteboarding revisited 199
Offering take-home tests 200
Reviewing code 201
Firing Fast 202
The jerk 202
The martyr 203
The underperformer 204

Chapter 15: Empowering Engineers 205
Scaling Engineering Teams with DevOps 205
Three stages of a company 206
Motivating Engineers 210
Researching motivation 211
DevOpsing motivation 212
Avoiding reliance on extrinsic rewards 212
Autonomy 213
Mastery 213
Purpose 214
Making work fun 214
Allowing people to choose their teams 215
Measuring Motivation 215

Part 4: Practicing Kaizen, the Art of Continuous Improvement 217
Chapter 16: Embracing Failure Successfully 219
Failing Fast in Tech 220
Failing safely 220
Containing failure 221
Accepting human error (and keeping it blameless) 222
Failing Well 222
Maintaining a growth mindset 223
Creating the freedom to fail 224

Chapter 17: Preparing for Incidents 229
Combating “Human Error” with Automation 230
Focusing on systems: Automating realistically 231
Using automation tools to avoid code integration problems 233
Handling deployments and infrastructure 234
Limiting overengineering 235
Humanizing On-Call Rotation 237
When on-call duties become inhumane 237
Humane on-call expectations 238
Managing Incidents 239
Making consistency a goal 240
Adopting standardized processes 241
Establishing a realistic budget 242
Making it easy to respond to incidents 243
Responding to an unplanned disruption 244
Empirically Measuring Progress 248
Mean time to repair (MTTR) 248
Mean time between failures (MTBF) 248
Cost per incident (CPI) 249

Chapter 18: Conducting Post-Incident Reviews 251
Going beyond Root Cause Analysis 252
Stepping through an Incident 253
Succeeding at Post-Incident Reviews 254
Scheduling it immediately 254
Including everyone 255
Keeping it blameless 255
Reviewing the timeline 255
Asking tough questions 256
Acknowledging hindsight bias 258
Taking notes 258
Making a plan 259

Part 5: Tooling Your DevOps Practice 261
Chapter 19: Adopting New Tools 263
Integrating with Open Source Software 264
Opening community innovation 264
Licensing open source 265
Deciding on open source 266
Transitioning to New Languages 268
Compiling and interpreting languages 268
Parallelizing and multithreading 269
Programming functionally 270
Managing memory 272
Choosing languages wisely 272

Chapter 20: Managing Distributed Systems 275
Working with Monoliths and Microservices 276
Choosing a monolithic architecture first 277
Evolving to microservices 278
Designing Great APIs 280
What’s in an API 280
Focusing on consistent design 281
Containers: Much More than Virtual Machines 284
Understanding containers and images 285
Deploying microservices to containers 285
Comparing orchestrators: Harmonize the hive 287
Configuring containers 289
Monitoring containers: Keeping them alive until you kill them 290
Securing containers: These boxes need a lock 292

Chapter 21: Migrating to the Cloud 295
Automating DevOps in the Cloud 295
Taking your DevOps culture to the cloud 296
Learning through adoption 296
Benefitting from cloud services 297
Cumulus, Cirrus, and Steel: Types of Clouds 298
Public cloud 298
Private cloud 299
Hybrid cloud 299
Cloud as a Service 300
Infrastructure as a Service 300
Platform as a Service 301
Software as a Service 301
Choosing the Best Cloud Service Provider 302
Amazon Web Services (AWS) 303
Microsoft Azure 303
Google Cloud Platform (GCP) 303
Finding Tools and Services in the Cloud 304

Part 6: The Part of Tens 307
Chapter 22: Top Ten (Plus) Reasons That DevOps Matters 309
Accepting Constant Change 309
Embracing the Cloud 310
Hiring the Best 310
Staying Competitive 311
Solving Human Problems 311
Challenging Employees 312
Bridging Gaps 312
Failing Well 313
Continuously Improving 313
Automating Toil 314
Accelerating Delivery 314

Chapter 23: Top Ten DevOps Pitfalls 315
Deprioritizing Culture 315
Leaving Others Behind 316
Forgetting to Align Incentives 317
Keeping Quiet 317
Forgetting to Measure 318
Micromanaging 318
Changing Too Much, Too Fast 319
Choosing Tools Poorly 320
Fearing Failure 320
Being Too Rigid 321

Index 323