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