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

Description

DevOps Culture and Practice with OpenShift features many different real-world practices - some people-related, some process-related, some technology-related - to facilitate successful DevOps, and in turn OpenShift, adoption within your organization. It introduces many DevOps concepts and tools to connect culture and practice through a continuous loop of discovery, pivots, and delivery underpinned by a foundation of collaboration and software engineering. Containers and container-centric application lifecycle management are now an industry standard, and OpenShift has a leading position in a flourishing market of enterprise Kubernetes-based product offerings. DevOps Culture and Practice with OpenShift provides a roadmap for building empowered product teams within your organization. This guide brings together lean, agile, design thinking, DevOps, culture, facilitation, and hands-on technical enablement all in one book. Through a combination of real-world stories, a practical case study, facilitation guides, and technical implementation details, DevOps Culture and Practice with OpenShift provides tools and techniques to build a DevOps culture within your organization on Red Hat's OpenShift Container Platform. What You Will Learn: * Implement successful DevOps practices and in turn OpenShift within your organization * Deal with segregation of duties in a continuous delivery world * Understand automation and its significance through an application-centric view * Manage continuous deployment strategies, such as A/B, rolling, canary, and blue-green * Leverage OpenShift's Jenkins capability to execute continuous integration pipelines * Manage and separate configuration from static runtime software * Master communication and collaboration enabling delivery of superior software products at scale through continuous discovery and continuous delivery Who this book is for: This book is for anyone with an interest in DevOps practices with OpenShift or other Kubernetes platforms. 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