Develop faster with DevOps

DevOps embraces a culture of unifying the creation and distribution of technology in a way that allows for faster release cycles and more resource-efficient product updating. DevOps For Dummies provides a guidebook for those on the development or operations side in need of a primer on this way of working.

Inside, DevOps evangelist Emily Freeman provides a roadmap for adopting the management and technology tools, as well as the culture changes, needed to dive head-first into DevOps.

Identify your organization’s needs
Create a DevOps framework
Change your organizational structure
Manage projects in the DevOps world

DevOps For Dummies is essential reading for developers and operations professionals in the early stages of DevOps adoption.

Emily Freeman is a technologist and storyteller who helps engineering teams improve their velocity. She believes the biggest challenges facing engineers aren't technical, but human. She's worked with both cutting-edge startups and some of the largest technology providers in the world. Emily is currently a Senior Cloud Advocate at Microsoft and a frequent keynote speaker at technology events.

Foreword Xvii

Introduction 1

About This Book 1

Foolish Assumptions 2

Icons Used in This Book 2

Beyond the Book 3

Where to Go from Here 3

Part 1: Demystifying DevOps 5

Chapter 1: Introducing DevOps 7

What Is DevOps? 7

DevOps evolved from Agile 8

DevOps focuses on people 8

Company culture is the foundation of DevOps 9

You learn by observing your process and collecting data 9

Persuasion is key to DevOps adoption 10

Small, incremental changes are priceless 10

Benefitting from DevOps 10

Keeping CALMS 11

Solving the problem of conflicting interests 13

Chapter 2: Designing Your Organization 15

Assessing Your Culture’s Health 16

Integrating DevOps 18

Establishing DevOps Values 18

Encourage teamwork 19

Reduce silos 19

Practice systems thinking 20

Embrace failure 20

Communicate, communicate, communicate 20

Accept feedback 21

Automate processes (when appropriate) 21

Modeling Company Culture 22

Avoiding the worst of tech culture 23

Crafting your vision 25

Incentivizing Your Values 26

Evaluations 27

Rewards 28

Chapter 3: Identifying Waste 31

Digging into the Seven Types of Waste 32

Unnecessary process 32

Waiting 33

Motion 33

Costs of defects 33

Overproduction 33

Transportation 34

Inventory 34

Understanding waste in DevOps 34

Rooting Out Waste 36

Discovering bottlenecks 36

Focusing on impact 39

Chapter 4: Persuading Colleagues to Try DevOps 43

Fearing Change 44

Persuading Those around You to Shift to DevOps 45

Earning executive support 48

Creating a groundswell in the engineering group 49

Managing the middle managers 50

Persuading the stubborn 50

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

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.