DevOps Culture and Practice with OpenShift: Deliver continuous business value through people, processes, and technology

Cover
FM
Table of Contents
Foreword
Preface
Acknowledgements
Section 1: Practices Make Perfect
Chapter 1: Introduction — Start with Why
Why — For What Reason or Purpose?
Why Should I Listen to These Folks?
Where Did This Book Come From?
Who Exactly Is This Book For?
From I to T to M
Conclusion
Chapter 2: Introducing DevOps and Some Tools
The Value Chain
The Gaps
The Big List of Things to Do
Demonstrating Value and Building the Right Thing
How Do We Do the Things on Our List?
Development to Operations
People, Process, and Technology
The Mobius Loop and the Open Practice Library
Conclusion
Chapter 3: The Journey Ahead
A Story about Telling a Practice
PetBattle – the Backstory
What about Legacy Systems?
Borrowing Brilliance
What to Expect from the Rest of This Book?
What about Distributed Teams?
Some Words about the World of 'Open'
Conclusion
Section 2: Establishing the Foundation
Chapter 4: Open Culture
Why Is It Important?
Information Radiators
Can You Make Those Red Lights Go Green, Please?
Culture
Motivation
PetBattle — Creating Autonomy, Mastery, and Purpose
Social Contracts
Do I Need One? If So, How Do I Build One?
It's OK to Be Wrong
Social Contracting for Distributed People
Stop the World
The Andon Cord and Psychological Safety
We're Just Rebuilding the Same Experience. Stop the World!
Losing Track of Original Purpose
Real-Time Retrospective
Team Identity
Socializing
Network Mapping
Team Logo and Prime Directive
Team Name + Building a Team Logo = the Beginning of Team Identity
Creating a Team Identity with Distributed People
Radiate Everything
Radiating Everything When Distributed
Team Sentiment
Blending Team Sentiment with Other Practices
Team Sentiment Achieving a Different Purpose – Banter!
Team Sentiment with Distributed People
Radiate Failures
Radiating Failure – as Useful (If Not More) as Radiating Success
Inspect and Adapt
PetBattle — Establishing the Cultural Foundation
Conclusion
Chapter 5: Open Environment and Open Leadership
The Kodak Problem
Learning from History
Open Leadership
Changing an Organization
Leading Sustainable Change
Achieving Greatness
Giving Intent
Moving Decisions to Where the Information Is
Setting the Environment
How Do We (as Leaders) Convince the Doubters?
No Computers in the Company! The 1990s or the 1890s?
Priority Sliders
Running Priority Sliders with Distributed People
The Space
The Minimal Viable Space
"We See What You Want To Do and Why and We'll Help You Get There" in Just 4 Weeks
Virtual Spaces
Conclusion
Chapter 6: Open Technical Practices – Beginnings, Starting Right
Green from Go!
Pair Programming and Mob Programming
Mob to Learn, Pair to Build
Containers and Being Container-Native
Container History
How Containers Work
Pipelines — CI or CD or CD²?
Derek the DevOps Dinosaur
Continuous Integration
Integrate Continuously
Continuous Delivery
Building Confidence in the Quality of the Software Delivery Pipeline
Continuous Deployment (CD²)
When the Work Is Done, Ship It!
Everything-as-Code
Can You Build a Second One of Those for Me, Please?
Establishing the Technical Foundation for PetBattle
Jenkins – Our Best Friend!
Helm Overview
Installing Jenkins Using Helm
Developer Workflows
GitFlow
GitHub Flow
Trunk-Based Development
Too Many Choices — Tell Me What to Do
Conclusion
Chapter 7: Open Technical Practices — The Midpoint
The Big Picture
PetBattle – Building a Big Picture
GitOps
ArgoCD
If It's Not in Git, It's Not Real!
Implementing GitOps
Testing Testing Testing!
The Test Automation Pyramid
Testing in Practice
Testing and the Definition of Done
TDD or BDD or DDT
BDD for Our Ops Tooling Python Library
Product Owners Seeing Their Thoughts in Code!
Example Mapping
Example Mapping in the Field
Non-functional Testing
Performance Testing Sam's Code
A Few Final Thoughts on Testing
Emerging Architecture
Observations from the Field
Conclusion
Section 3: Discover It
Chapter 8: Discovering the Why and Who
The North Star
PetBattle as a Business
Our North Star at Open Innovation Labs
Impact Mapping
Start with the WHY — the Goal
PetBattle – the Goal
WHO Can Help Us Reach the Desired Effect? The Actors
PetBattle – the Actors
HOW Should Our Actors’ Behaviors Change? The Impacts
PetBattle – the Impacts
WHAT Should We Build? The Deliverables
PetBattle – the Deliverables
PetBattle – Placing Bets
Hypothesis Examples
Connecting Engineers to Business Outcomes
Human-Centered Design
UX Design and Empathy Mapping a PetBattle User
Users Do Strange and Unexpected Things
Empathy Mapping an Organization — Dev versus Ops
Engineers Build Out Empathy Maps during User Interviews
Conclusion
Chapter 9: Discovering the How
Event Storming
What Is Event Storming?
The Ingredients
The Recipe
Event Storming with Doubters
PetBattle Event Storm
Final Thoughts on Event Storming
Emerging Architecture
Transitioning an Event Storm to an Emergent Architecture
The Non-Functional Map
From Non-Functional Map to Backlog
Discovering the Case for Continuous Delivery
Metrics-Based Process Map
Finding and Making Improvements
Improving through Iteration
Scoping an Entire Engagement Using MBPM
PetBattle – MBPM
Conclusion
Chapter 10: Setting Outcomes
What Is an Outcome?
Outcomes versus Outputs
Why Have Target Outcomes?
How to Capture Target Outcomes
Examples of Target Outcomes
Visualizing Target Outcomes
Optimizing Target Outcomes
Chaining Target Outcomes with Other Practices
PetBattle Target Outcomes
The Balance of Three: People/Process/Technology
Target Outcomes from a Telecoms Product – Stopwatch at the Ready!
Differentiating between Primary Outcomes and Enabling Outcomes
Software Delivery Metrics
Platform Adoption Metrics
Continuous Metrics Inspection
Creating a Discovery Map
Conclusion
Section 4: Prioritize It
Chapter 11: The Options Pivot
Value Slicing
The Beer and the Curry
One to Few to Many Slices of Value – Continuous Delivery
PetBattle – Slicing Value towards Continuous Delivery
Design of Experiments
Qualitative versus Quantitative Feedback
Impact and Effort Prioritization Matrix
How-Now-Wow Prioritization
The Design Sprint
Forming the Initial Product Backlog
PetBattle — Tracing Value through Discovery and Delivery Practices
Product Backlog Refinement
Prioritization
Value versus Risk
Cost of Delay and WSJF
PetBattle – Prioritizing using WSJF
Product Ownership
Experimenting with Different Product Owners
Patterns of Early Sprints and the Walking Skeleton
Advanced Deployment Considerations
A/B Testing
Blue/Green Deployments
Canary Releases
Dark Launches
Feature Flags
PetBattle – Tech Spikes, Prototypes, Experiments, and Feature Implementations
Reframing the Question – How Much Can I Borrow or How Much House Can I Afford?
Research, Experiment, Implement
Creating an Options Map
Conclusion
Section 5: Deliver It
Chapter 12: Doing Delivery
Waterfall
The Birth of Agile
How Does OpenShift Help?
Decision-Making Contexts
The Cynefin Framework
The Ferrari and the Rainforest
When Does a Mobius Loop Mindset Make Sense?
PetBattle—Complex, Complicated, or Clear?
The Definition of Ready
PetBattle – Definition of Ready
Scrum
The 3-5-3 Formation
The Product Owner Role
The ScrumMaster Role
The Development Team Role
The Product Backlog Artifact
The Sprint Backlog Artifact
The Product Increment Artifact
Show Me the Product!
The Sprint Planning Event
The Daily Scrum Event
The Sprint Review Event
When WOULD We Have Uncovered This In a Traditional Mode of Delivery?
The Sprint Retrospective Event
The Pub Retro!
A Sprint in the Life of PetBattle: Getting Ready
A Sprint in the Life of PetBattle: Sprint 1 Planning
A Sprint in the Life of PetBattle: Sprint 1 Delivery
A Sprint in the Life of PetBattle: Sprint 1 Review And Retrospective
Using Scrum with distributed people
When should we stop Scrumming?
Teams asking questions that suggest we've matured out of Scrum
Kanban
Kanban Board!
PetBattle – Release Early, Release Often, Release Continuously
The Definition of Done
PetBattle – Definition of Done
Bad Agile Smells
Conclusion
Chapter 13: Measure and Learn
Metrics-Driven Transformation
Where to Measure and Learn
The Showcase
The Retrospective
The Retrospective – an Engineering Perspective
Inspecting the Build Stats at Retrospectives
Experiments – the Results!
User Testing
Usability Testing
"We Are Not Our Users"
Guerrilla Testing
Guerrilla testing with a box of donuts in a busy Dublin bank!
PetBattle Usability Testing
What to Measure?
Measuring Service Delivery and Operational Performance (SDO)
Pelorus
Measuring Lean Metrics
Measuring SLOs, SLAs, and SLIs
PetBattle Service Levels
Measuring Security
PetBattle Security
Measuring Performance
PetBattle Performance
Measuring Deployment Pain
Measuring Culture
Measuring Application Metrics
PetBattle Application Metrics
Measuring Infrastructure Platform Costs and Utilization
Measuring Resources and Services
User Experience Analytics
PetBattle User Experience Analytics
Visualize Measurable Outcomes
Proactive Notification
Altering the Customers
Having Fun with Notifications and the Build!
Creating a Delivery Map
Conclusion
Section 6: Build It, Run It, Own It
Chapter 14: Build It
Cluster Resources
Existing PetBattle Architecture
PetBattle Components
Plan of Attack
Running PetBattle
Argo CD
Trunk-Based Development and Environments
The Anatomy of the App-of-Apps Pattern
Build It – CI/CD for PetBattle
The Big Picture
The Build
The Bake
The Deploy
System Test
Promote
Choose Your Own Adventure
Jenkins–The Frontend
Connect Argo CD to Git
Secrets in Our Pipeline
The Anatomy of a Jenkinsfile
Branching
Webhooks
Jenkins
Bringing It All Together
What's Next for Jenkinsfile
Tekton–The Backend
Tekton Basics
Reusable Pipelines
Build, Bake, Deploy with Tekton
Triggers and Webhooks
GitOps our Pipelines
Which One Should I Use?
Conclusion
Chapter 15: Run It
The Not Safe For Families (NSFF) Component
Why Serverless?
Generating or Obtaining a Pre-trained Model
The OpenShift Serverless Operator
Deploying Knative Serving Services
Invoking the NSFF Component
Let's Talk about Testing
Unit Testing with JUnit
Service and Component Testing with REST Assured and Jest
Service Testing with Testcontainers
End-to-End Testing
Pipelines and Quality Gates (Non-functionals)
SonarQube
Perf Testing (Non-Functional)
Resource Validation
Image Scanning
Linting
Code Coverage
Untested Software Watermark
The OWASP Zed Attack Proxy (ZAP)
Chaos Engineering
Accidental Chaos Testing
Advanced Deployments
A/B Testing
The Experiment
Matomo – Open Source Analytics
Deploying the A/B Test
Understanding the results
Blue/Green deployments
Deployment previews
Conclusion
Chapter 16: Own It
Observability
Probes
Domino Effect
Fault Tolerance
Logging
Tracing
Metrics
Configuring Prometheus To Retrieve Metrics From the Application
Visualizing the Metrics in OpenShift
Querying using Prometheus
Visualizing Metrics Using Grafana
Metadata and Traceability
Labels
Software Traceability
Annotations
Build Information
Alerting
What Is an Alert?
Why Alert?
Alert Types
Managing Alerts
User-Defined Alerts
OpenShift Alertmanager
Service Mesh
Why Service Mesh?
Aside – Sidecar Containers
Here Be Dragons!
Service Mesh Components
PetBattle Service Mesh Resources
Operators Everywhere
Operators Under the Hood
Control Loops
Operator Scopes
Operators in PetBattle
Service Serving Certificate Secrets
Conclusion
Section 7: Improve It, Sustain It
Chapter 17: Improve It
What Did We Learn?
Did We Learn Enough?
We Need Two Apps, Not One!
"Just Enough" Leads to Continuous Everything
Learning from Security Experts
Always Improve Metrics and Automation
Revisiting the Metrics-Based Process Map
My management only really understand numbers and spreadsheets
Improve the Technology
Long Live the Team
Visualizing the Transition from I to T to M
Wizards and Cowboys
Conclusion
Chapter 18: Sustain It
The Journey So Far
Infectious Enthusiasm
Demo Day
Documenting the Journey
Sketching the Experience
Walk the Walls
Written Showcases
Word of Mouth
Mind-Blowing Metrics That Cannot Be Ignored
Transitioning From One Team To Seven Teams
More Teams, More Application Products
The Power of Three Iterations in Enablement
The App Does Something This Week That It Didn’t Do Last Week!
Bolster the Foundations
Sustaining the Technology
The Double Mobius Loop – Platform and Application Product
Connecting Many Levels of Product Teams
Conclusion
Appendix A – OpenShift Sizing Requirements for Exercises
How To Resize Storage in Your CRC Virtual Machine
Tekton Persistent Storage
Appendix B – Additional Learning Resources
Index