Continuous Delivery

Reliable Software Releases through Build, Test, and Deployment Automation

Jez Humble, David Farley

Publisher: Addison-Wesley, 2011, 463 pages

ISBN: 978-0-321-60191-9

Keywords: DevOps

Last modified: June 13, 2015, 5:24 p.m.

Getting software released to users is often a painful, risky, and time-consuming process. This groundbreaking new book sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers, and operations, delivery teams can get changes released in a matter of hours — sometimes even minutes–no matter what the size of a project or the complexity of its code base.

Jez Humble and David Farley begin by presenting the foundations of a rapid, reliable, low-risk delivery process. Next, they introduce the "deployment pipeline," an automated process for managing all changes, from check-in to release. Finally, they discuss the "ecosystem" needed to support continuous delivery, from infrastructure, data and configuration management to governance.

The authors introduce state-of-the-art techniques, including automated infrastructure management and data migration, and the use of virtualization. For each, they review key issues, identify best practices, and demonstrate how to mitigate risks. Coverage includes

  • Automating all facets of building, integrating, testing, and deploying software
  • Implementing deployment pipelines at team and organizational levels
  • Improving collaboration between developers, testers, and operations
  • Developing features incrementally on large and distributed teams
  • Implementing an effective configuration management strategy
  • Automating acceptance testing, from analysis to implementation
  • Testing capacity and other non-functional requirements
  • Implementing continuous deployment and zero-downtime releases
  • Managing infrastructure, data, components and dependencies
  • Navigating risk management, compliance, and auditing

Whether you’re a developer, systems administrator, tester, or manager, this book will help your organization move from idea to release faster than ever — so you can deliver value to your business rapidly and reliably.

  • Part I Foundations
    • Chapter 1 The Problem of Delivering Software
      • Introduction
      • Some Common Release Antipatterns
        • Antipattern: Deploying Software Manually
        • Antipattern: Deploying to a Production-like Environment Only after Development is Complete
        • Antipattern: Manual Configuration Management of Production Environments
        • Can We Do Better?
      • How Do We Achieve our Goal?
        • Every Change Should Trigger the Feedback Process
        • The Feedback Must Be Received as Soon as Possible
        • The Delivery Team Must Receive Feedback and Then Act on it
        • Does This Process Scale?
      • What Are the Benefits?
        • Empowering Teams
        • Reducing Errors
        • Lowering Stress
        • Deployment Flexibility
        • Practice Makes Perfect
      • The Release Candidate
        • Every Check-in Leads to a Potential Release
      • Principles of Software Delivery
        • Create a Repeatable, Reliable Process for Releasing Software
        • Automate Almost Everything
        • Keep Everything in Version Control
        • If it Hurts, Do It More Frequently, and Bring the Pain Forward
        • Build Quality In
        • Done Means Released
        • Everybody Is Responsible for the Delivery Process
        • Continuous Improvement
      • Summary
    • Chapter 2 Configuration Management
      • Introduction
      • Using Version Control
        • Keep Absolutely Everything in Version Control
        • Check in Regularly to Trunk
        • Use Meaningful Commit Messages
      • Managing Dependencies
        • Managing External Libraries
        • Managing Components
      • Managing Software Configuration
        • Configuration and Flexibility
        • Types of Configuration
        • Managing Application Configuration
        • Managing Configuration across Applications
        • Principles of Managing Application Configuration
      • Managing Your Environments
        • Tools to Manage Environments
        • Managing the Change Process
      • Summary
    • Chapter 3 Continuous Integration
      • Introduction
      • Implementing Continuous Integration
        • What You Need Before You Start
        • A Basic Continuous Integration System
      • Prerequisites for Continuous Integration
        • Check in Regularly
        • Create a Comprehensive Automated Test Suite
        • Keep the Build and Test Process Short
        • Managing Your Development Workspace
      • Using Continuous Integration Software
        • Basic Operation
        • Bells and Whistles
      • Essential Practices
        • Don't Check in on a Broken Build
        • Always Run All Commit Tests Locally before Committing, or Get your CI Server to Do it for you
        • Wait for Commit Tests to Pass before Moving on
        • Never Go Home on a Broken Build
        • Always Be Prepared to Revert to the Previous Revision
        • Time-Box Fixing before Reverting
        • Don't Comment Out Failing Tests
        • Take Responsibility for All Breakages that Result from Your Changes
        • Test-Driven Development
      • Suggested Practices
        • Extreme Programming (XP) Development Practices
        • Failing a Build for Architectural Breaches
        • Failing the Build for Slow Tests
        • Failing the Build for Warnings and Code Style Breaches
      • Distributed Teams
        • The Impact on Process
        • Centralized Continuous Integration
        • Technical Issues
        • Alternative Approaches
      • Distributed Version Control Systems
      • Summary
    • Chapter 4 Implementing a Testing Strategy
      • Introduction
      • Types of Tests
        • Business-Facing Tests That Support the Development Process
        • Technology-Facing Tests That Support the Development Process
        • Business-Facing Tests That Critique the Project
        • Technology-Facing Tests That Critique the Project
        • Test Doubles
      • Real-Life Situations and Strategies
        • New Projects
        • Midproject
        • Legacy Systems
        • Integration Testing
      • Process
        • Managing Defect Backlogs
      • Summary
  • Part II The Deployment Pipeline
    • Chapter 5 Anatomy of the Deployment Pipeline
      • Introduction
      • What is a Deployment Pipeline?
        • A Basic Deployment Pipeline
      • Deployment Pipeline Practices
        • Only Build Your Binaries Once
        • Deploy the Same Way to Every Environment
        • Smoke-Test Your Deployments
        • Deploy into a Copy of Production
        • Each Change Should Propagate through the Pipeline Instantly
        • If Any Part of the Pipeline Fails, Stop the Line
      • The Commit Stage
        • Commit Stage Best Practices
      • The Automated Acceptance Test Gate
        • Automated Acceptance Test Best Practices
      • Subsequent Test Stages
        • Manual Testing
        • Nonfunctional Testing
      • Preparing to Release
        • Automating Deployment and Release
        • Backing Out Changes
        • Building on Success
      • Implementing a Deployment Pipeline
        • Modeling Your Value Stream and Creating a Walking Skeleton
        • Automating the Build and Deployment Process
        • Automating the Unit Tests and Code Analysis
        • Automating Acceptance Tests
        • Evolving Your Pipeline
      • Metrics
      • Summary
    • Chapter 6 Build and Deployment Scripting
      • Introduction
      • An Overview of Build Tools
        • Make
        • Ant
        • NAnt and MSBuild
        • Maven
        • Rake
        • Buildr
        • Psake
      • Principles and Practices of Build and Deployment Scripting
        • Create a Script for Each Stage in Your Deployment Pipeline
        • Use an Appropriate Technology to Deploy Your Application
        • Use the Same Scripts to Deploy to Every Environment
        • Use Your Operating System's Packaging Tools
        • Ensure the Deployment Process is Idempotent
        • Evolve Your Deployment System Incrementally
      • Project Structure for Applications That Target the JVM
        • Project Layout
      • Deployment Scripting
        • Deploying and Testing Layers
        • Testing Your Environment's Configuration
      • Tips and Tricks
        • Always use Relative Paths
        • Eliminate Manual Steps
        • Build in Traceability from Binaries to Version Control
        • Don't Check Binaries into Version Control as Part of Your Build
        • Test Targets Should Not Fail the Build
        • Constrain Your Application with Integrated Smoke Tests
        • .NET Tips and Tricks
      • Summary
    • Chapter 7 The Commit Stage
      • Introduction
      • Commit Stage Principles and Practices
        • Provide Fast, Useful Feedback
        • What Should Break the Commit Stage?
        • Tend the Commit Stage Carefully
        • Give Developers Ownership
        • Use a Build Master for Very Large Teams
      • The Results of the Commit Stage
        • The Artifact Repository
      • Commit Test Suite Principles and Practices
        • Avoid the User Interface
        • Use Dependency Injection
        • Avoid the Database
        • Avoid Asynchrony in Unit Tests
        • Using Test Doubles
        • Minimizing State in Tests
        • Faking Time
        • Brute Force
      • Summary
    • Chapter 8 Automated Acceptance Testing
      • Introduction
      • Why is Automated Acceptance Testing Essential?
        • How to Create Maintainable Acceptance Test Suites
        • Testing against the GUI
      • Creating Acceptance Tests
        • The Role of Analysts and Testers
        • Analysis on Iterative Projects
        • Acceptance Criteria as Executable Specifications
      • The Application Driver Layer
        • How to Express Your Acceptance Criteria
        • The Window Driver Pattern: Decoupling the Tests from the GUI
      • Implementing Acceptance Tests
        • State in Acceptance Tests
        • Process Boundaries, Encapsulation, and Testing
        • Managing Asynchrony and Timeouts
        • Using Test Doubles
      • The Acceptance Test Stage
        • Keeping Acceptance Tests Green
        • Deployment Tests
      • Acceptance Test Performance
        • Refactor Common Tasks
        • Share Expensive Resources
        • Parallel Testing
        • Using Compute Grids
      • Summary
    • Chapter 9 Testing Nonfunctional Requirements
      • Introduction
      • Managing Nonfunctional Requirements
        • Analyzing Nonfunctional Requirements
      • Programming for Capacity
      • Measuring Capacity
        • How Should Success and Failure Be Defined for Capacity Tests?
      • The Capacity-Testing Environment
      • Automating Capacity Testing
        • Capacity Testing via the User Interface
        • Recording Interactions against a Service or Public API
        • Using Recorded Interaction Templates
        • Using Capacity Test Stubs to Develop Tests
      • Adding Capacity Tests to the Deployment Pipeline
      • Additional Benefits of a Capacity Test System
      • Summary
    • Chapter 10 Deploying and Releasing Applications
      • Introduction
      • Creating a Release Strategy
        • The Release Plan
        • Releasing Products
      • Deploying and Promoting Your Application
        • The First Deployment
        • Modeling Your Release Process and Promoting Builds
        • Promoting Configuration
        • Orchestration
        • Deployments to Staging Environments
      • Rolling Back Deployments and Zero-Downtime Release
        • Rolling Back by Redeploying the Previous Good Version
        • Zero-Downtime Releases
        • Blue-Green Deployments
        • Canary Releasing
      • Emergency Fixes
      • Continuous Deployment
        • Continuously Releasing User-Installed Software
      • Tips and Tricks
        • The People Who Do the Deployment Should Be Involved in Creating the Deployment Process
        • Log Deployment Activities
        • Don't Delete the Old Files, Move Them
        • Deployment is the Whole Team's Responsibility
        • Server Applications Should Not Have GUIs
        • Have a Warm-Up Period for a New Deployment
        • Fail Fast
        • Don't Make Changes Directly on the Production Environment
      • Summary
  • Part III The Delivery Ecosystem
    • Chapter 11 Managing Infrastructure and Environments
      • Introduction
      • Understanding the Needs of the Operations Team
        • Documentation and Auditing
        • Alerts for Abnormal Events
        • IT Service Continuity Planning
        • Use the Technology the Operations Team is Familiar With
      • Modeling and Managing Infrastructure
        • Controlling Access to Your Infrastructure
        • Making Changes to Infrastructure
      • Managing Server Provisioning and Configuration
        • Provisioning Servers
        • Ongoing Management of Servers
      • Managing the Configuration of Middleware
        • Managing Configuration
        • Research the Product
        • Examine How Your Middleware Handles State
        • Look for a Configuration API
        • Use a Better Technology
      • Managing Infrastructure Services
        • Multihomed Systems
      • Virtualization
        • Managing Virtual Environments
        • Virtual Environments and the Deployment Pipeline
        • Highly Parallel Testing with Virtual Environments
      • Cloud Computing
        • Infrastructure in the Cloud
        • Platforms in the Cloud
        • One Size Doesn't Have to Fit All
        • Criticisms of Cloud Computing
      • Monitoring Infrastructure and Applications
        • Collecting Data
        • Logging
        • Creating Dashboards
        • Behavior-Driven Monitoring
      • Summary
    • Chapter 12 Managing Data
      • Introduction
      • Database Scripting
        • Initializing Databases
      • Incremental Change
        • Versioning Your Database
        • Managing Orchestrated Changes
      • Rolling Back Databases and Zero-Downtime Releases
        • Rolling Back without Losing Data
        • Decoupling Application Deployment from Database Migration
      • Managing Test Data
        • Faking the Database for Unit Tests
        • Managing the Coupling between Tests and Data
        • Test Isolation
        • Setup and Tear Down
        • Coherent Test Scenarios
      • Data Management and the Deployment Pipeline
        • Data in Commit Stage Tests
        • Data in Acceptance Tests
        • Data in Capacity Tests
        • Data in Other Test Stages
      • Summary
    • Chapter 13 Managing Components and Dependencies
      • Introduction
      • Keeping Your Application Releasable
        • Hide New Functionality Until It Is Finished
        • Make All Changes Incrementally
        • Branch by Abstraction
      • Dependencies
        • Dependency Hell
        • Managing Libraries
      • Components
        • How to Divide a Codebase into Components
        • Pipelining Components
        • The Integration Pipeline
      • Managing Dependency Graphs
        • Building Dependency Graphs
        • Pipelining Dependency Graphs
        • When Should We Trigger Builds?
        • Cautious Optimism
        • Circular Dependencies
      • Managing Binaries
        • How an Artifact Repository Should Work
        • How Your Deployment Pipeline Should Interact with the Artifact Repository
      • Managing Dependencies with Maven
        • Maven Dependency Refactorings
      • Summary
    • Chapter 14 Advanced Version Control
      • Introduction
      • A Brief History of Revision Control
        • CVS
        • Subversion
        • Commercial Version Control Systems
        • Switch Off Pessimistic Locking
      • Branching and Merging
        • Merging
        • Branches, Streams, and Continuous Integration
      • Distributed Version Control Systems
        • What Is a Distributed Version Control System?
        • A Brief History of Distributed Version Control Systems
        • Distributed Version Control Systems in Corporate Environments
        • Using Distributed Version Control Systems
      • Stream-Based Version Control Systems
        • What Is a Stream-Based Version Control System?
        • Development Models with Streams
        • Static and Dynamic Views
        • Continuous Integration with Stream-Based Version Control Systems
      • Develop on Mainline
        • Making Complex Changes without Branching
      • Branch for Release
      • Branch by Feature
      • Branch by Team
      • Summary
    • Chapter 15 Managing Continuous Delivery
      • Introduction
      • A Maturity Model for Configuration and Release Management
        • How to Use the Maturity Model
      • Project Lifecycle
        • Identification
        • Inception
        • Initiation
        • Develop and Release
        • Operation
      • A Risk Management Process
        • Risk Management 101
        • Risk Management Timeline
        • How to Do a Risk-Management Exercise
      • Common Delivery Problems — Their Symptoms and Causes
        • Infrequent or Buggy Deployments
        • Poor Application Quality
        • Poorly Managed Continuous Integration Process
        • Poor Configuration Management
      • Compliance and Auditing
        • Automation over Documentation
        • Enforcing Traceability
        • Working in Silos
        • Change Management
      • Summary

Reviews

Continuous Delivery

Reviewed by Roland Buresund

Very Good ******** (8 out of 10)

Last modified: June 13, 2015, 5:24 p.m.

Long, repetitive, and sometimes boring, but contains a lot of truths that we in the IT industry sometimes tries to forget.

Still, I would recommend this for anyone working in IT. From developers and operators to group and mid-range managers.

Comments

There are currently no comments

New Comment

required

required (not published)

optional

required