Accelerate DevOps with GitHub

Enhance Software Delivery Performance with GitHub Issues, Projects, Actions, and Advanced Security

This is the companion repository for my book Accelerate DevOps with GitHub. You can find all hands-on labs and other examples from the book here. I also provide all the links and references from the chapters.

Part 1: Lean Management and Collaboration

In Part 1 you will learn how to reduce ballast from your development process and move to a lean and collaborative way of working that allows your teams to accelerate their value delivery. You’ll learn how to use GitHub to work together from everywhere effectively and use work insights and the right metrics to optimize your engineering productivity.

Chapter 1: Metrics that Matter

In this chapter I explain how to measure engineering velocity and developer productivity and how to make your DevOps acceleration measurable. The following topics will are covered in this chapter:

• Why Accelerate?
• Engineering Velocity
• High Performance Companies
• Measuring metrics that matter
• The SPACE of Developer Productivity
• Objectives and Key-Results

Chapter 2: Plan, Track, and Visualize Your Work

In this chapter we will focus on organizing your work inside your team and apply Lean Principles. You’ll learn how GitHub Issues and Projects can help you to simplify your flow of work.

In this chapter we will cover the following topics:

• Work is work
• Unplanned work and rework
• Visualizing your work
• Limiting work in progress (WIP)
• GitHub issues, labels, and milestones
• GitHub projects

Highlights:

• Follow the About GitHub markdown for all updates on GitHub flavored markdown. See this page for the source and rendered version.
• See the issue templates in action.
• Check out the Team Backlog - an example for GitHub Projects.
• See the Azure Boards integration

Chapter 3: Teamwork and Collaborative Development

A high performing team is more than the sum of its members, and it takes a high performing team to build products that people love. In this chapter you’ll learn how to set up your team for high collaborative development using pull requests. You’ll learn what a pull request is and what features can help you to get a good code review workflow for your team. The following are the core topics that we will cover in this chapter:

• Software development is a team sport
• The heart of collaboration: the pull request
• Propose changes using pull requests
• Pull request reviews
• Finishing pull request
• Best practices for code reviews

Hands-on exercices: ✋

1. Create a pull request
2. Review Changes

Chapter 4: Asynchronous Work: Collaborate from Anywhere

In this chapter we’ll focus on synchronous and asynchronous work and how you can use the benefits of asynchronous workflows for a better collaboration in distributed, remote, and hybrid teams and a better cross-team collaboration. The following are the topics that will be covered in the chapter:

• Comparing synchronous and asynchronous work
• Distributed teams
• Cross-team collaboration
• GitHub Discussions
• GitHub Pages and Wikis
• Working from everywhere with GitHub Mobile

Highlights:

• Discussions in the main menu of this repository.
• GitHub Pages: see the rendered output and check out the files in /docs that are the source - especially the _config.yml.
• Sample GitHub Wiki.
• Also see the sample pages for a ToC in AsciiDoc and MediaWiki.
• A sample for navigation and ToC in a custom wiki can be found here.

Chapter 5: The Influence of Open and Inner Source on Software Delivery Performance

In this chapter I explain the history of free and open-source software and why it has become so important over the last years. I will explain the impact it can have on your engineering velocity and how you can use the principles of open source for better cross-team collaboration in your company (inner source). The chapter will cover:

• History of free and open-source software
• The difference between open source and open development
• Benefits of embracing open source for companies
• Implementing an open-source strategy
• Open and inner source
• Importance for insourcing
• GitHub Sponsors

Featured open-source projects to sponsor:

• curl is the example for an organization that you can sponsor. Curl is used every day by thousands of developers worldwide (sponsor the project here).
• Dennis Doomen is the example for Sponsor tiers. He is the author of FluentAssertions - a .NET library I use in most of my C# projejcts (sponsor Dennis here).
• Jan De Dobbeleer is the example for Sponsorship goals. He is the maintainer of oh-my-posh - a highly customizable and extensible prompt theme engine for PowerShell (sponsor Jan here).

At the time writing the book, GitHub Sponsors was new and I worked with some of the mainters mentioned to set this up in a good way. So not all projects made it here - for example oh-my-zsh, which I use every day and which was the inspiration for oh-my-posh.

Part 2: Engineering DevOps Practices

Part 2 explains the most important engineering practices for effective DevOps. You’ll learn how to use GitHub Actions to automate your release pipelines and other engineering tasks, how to work trunk-based and with feature-flags and how to shift left security and quality assurance.

Chapter 6: Automation with GitHub Actions

This chapter explains the importance of automation for quality and speed. It introduces you to GitHub Actions and how you can use them for any kind of automation – not only continuous delivery.

• Overview of GitHub Actions
• Workflows, pipelines, and actions
• YAML basics
• The workflow syntax
• Working with secrets
• ✋ Hands-on: Your first workflow
• ✋ Hands-on: Your first action

Chapter 7: Running Your Workflows

In this chapter, I’ll show you the different options for running your workflows. We’ll investigate hosted and self-hosted runners, and I’ll explain how you can tackle hybrid-cloud scenarios or hardware-in-the-loop tests using the different hosting options. I’ll also show you how to set up, manage, and scale self-hosted runners, and I’ll show you how you can approach monitoring and troubleshooting. The following are the core topics that we will cover in this chapter:

• Hosted runners
• Self-hosted runners
• Managing access with runner groups
• Using labels
• Scaling your self-hosted runners
• Monitoring and troubleshooting

Chapter 8: Managing Dependencies Using GitHub Packages

This chapter describes how you can use GitHub Packages, semantic Versioning together with GitHub Actions to manage dependencies between your teams and products. The main topics are as follows:

• GitHub Packages
• ✋ Hands-on: Use npm packages with Actions
• ✋ Hands-on: Use Docker with Packages
• Apache Maven, Gradle, NuGet, and RubyGems packages

Chapter 9: Deploy to Any Platform

In this chapter I'll show you how you can easily deploy to any cloud and any platform in a secure and compliant way. The chapter will cover:

• Staged deployments
• Automate your deployments
• ✋ Hands-on: Deploy to Azure App Service
• ✋ Hands-on: Deploy to AWS Elastic Container Service (ECS)
• ✋ Hands-on: Deploy to Google Kubernetes Engine (GKE)
• Infrastructure as Code
• Workflow templates
• Reusable workflows and how they are used
• Measuring success

Chapter 10: Feature Flags and the Feature Lifecycle

This chapter explains how Feature Flags – or Feature Toggles - can help you to reduce complexity and manage the lifecycle of features and your software.The main topics of this chapter are:

• What are Feature Flags
• The lifecycle of features
• The benefits of Feature Flags
• Getting started with Feature Flags
• Feature Flags and technical debt
• Experimentation with Feature Flags

Chapter 11: Trunk-based Development

This chapter explains the benefits of trunk-based development and introduces you to the best git workflows to accelerate your software delivery.

The chapter covers:

• Trunk-based development
• Why you should avoid complex branching
• Other git workflows
• Accelerate with MyFlow

Part 3: Release with Confidence

Part 3 explains how you can accelerate even further and release frequently with confidence by baking quality assurance and security into your release pipelines. This includes concepts like shifting left testing and security, testing in production, chaos engineering, DevSecOps, securing your software supply chain, and ring-based deployments.

Chapter 12: Shift Left Testing for Increased Quality

takes a closer look at the role of quality assurance and testing on developer velocity and shows how you can shift left testing with test automation. The chapter also covers testing in production and chaos engineering.

Main topics in the chapter are:

• Shift left testing with test automation
• Eradicating flaky tests
• Code coverage
• Shift right – testing in production
• Fault injection and chaos engineering
• Tests and compliance
• Test management in GitHub

Chapter 13, Shift Left Security ad DevSecOps

This chapter takes a broader look at the role of security in software development and how you can bake security into the process and practice DevSecOps, zero-trust, and how you can shift left security. The chapter looks at common attack scenarios and how you can practice security and create awareness using attack simulations and red team | blue team exercises. The chapter also introduces you to GitHub Codespaces as a secure development environment in the cloud.

The key points that we will cover in this chapter are:

• Shift left security
• Assume breach, zero trust, and a security first mindset
• Attack simulations
• Red team | blue team exercises
• Attack scenarios
• GitHub Codespaces

Chapter 14, Securing Your Code

This chapter describes how you can use GitHub Advanced Security to eliminate bugs, security, and compliance issues by performing static code analysis with CodeQL and other tools, successfully manage your software supply chain with Dependabot, and eliminate secrets in your code base using Secret Scanning.

The key topics in this chapter are:

• Dependency management and Dependabot
• Automate dependabot with GitHub Actions (see auto-merge.yml and dependabot.yml)
• Secret Scanning
• Code Scanning
• Writing your own CodeQL queries

Chapter 15, Securing Your Deployments

This chapter shows how you can secure deployments to your environments and how you can automate your complete release pipeline in a secure, compliant way to also meet regulatory requirements. The chapter covers Software Bills of Meterials (SBoM), code and commit signing, dynamic application security testing, and security hardening your release pipelines. We will cover the following main topics in this chapter:

• Container and infrastructure security scanning
• Automate the infrastructure change process
• Source code and infrastructure integrity
• Signing commits and code
• Dynamic Application Security Testing
• Security hardening your release pipeline

Part 4: Software Architecture

Part 4 is about the correlation of your software architecture and the communication in your organization. You’ll learn how to transform your monolith gradually to a loosely coupled, event-based architecture.

Chapter 16: Loosely Coupled Architecture and Microservices

In this chapter I’ll give you an overview of loosely coupled systems and how you can evolve your software and system design to achieve a high engineering velocity. The following topics will be covered in this chapter:

• Loosely coupled systems
• Microservices
• Evolutionary design
• Event-based architecture

Chapter 17: Empower Your Teams

This chapter is about the correlation of the communication structure of your organization and your system architecture (Conway’s law) and how you can use this to improve architecture, organization structure, and software delivery performance. It covers the two-pizza team, the Inverse Conway Maneuver, and a mono- versus multi-repo strategy for your code. The following are the core topics in this chapter:

• Conway's law
• The two-pizza team
• Inverse Conway Maneuver
• Delivery cadence
• Mono- or multi-repo strategy

Part 5: Lean Product Management

In Part 5 you’ll learn the importance of lean product management, how to integrate customer feedback into your flow of work, and how to combine hypothesis-driven development with OKR.

Chapter 18: Lean Product Development and Lean Startup

This chapter is about the importance of lean product management at a product and feature level. It shows how you can incorporate customer feedback into your product management, create Minimal Viable Products, and how you can manage your enterprise portfolio. This chapter covers:

• Lean product development
• Incorporate customer feedback
• The Minimal Viable Product
• Enterprise portfolio management
• Business Model Canvas

Chapter 19: Experimentation and A|B-Testing

This chapter explains how you can evolve and continuously improve your products by conducting experiments to validate hypotheses through evidence-based DevOps practices like A|B-testing. It also explains how you can leverage OKR to empower your teams to conduct the right experiments and to build the right products. The following topics will be covered in this chapter:

• Conducting experiments with the scientific method
• Effective A|B testing with GrowthBook and Flagger
• Experimentation and OKR

Part 6: GitHub for your Enterprise

In Part 6 you’ll learn about the different hosting and pricing options of GitHub, how you can migrate to GitHub from other platforms, and best practices for structuring your teams and products inside GitHub Enterprise.

Chapter 20: GitHub: The Home for All Developer

This chapter explains how GitHub can serve as the holistic, open platform for your teams. It explains the different hosting options, pricing, and how you can integrate it in your existing toolchain. The key topics are:

• Hosting options and pricing
• GitHub Connect
• Hands-on: create your account on GitHub.com
• Enterprise Security
• GitHub Learning Labs

Chapter 21: Migrating to GitHub

If you are not a start-up, then you always have existing tools and processes that must be considered when moving to a new platform. In this chapter, we will discuss different strategies related to migrating to GitHub from different platforms. In this chapter, we will cover the following:

• Picking the right migration strategy
• Achieving compliance with low-fidelity migrations
• Synchronizing requirements for a smooth transition
• Migrating from Azure DevOps with the GitHub Enterprise Importer
• Migrating pipelines using Valet

Chapter 22: Organize Your Teams

In this chapter you’ll learn best-practices to structure your repositories and teams into organizations and enterprises to foster collaboration and facilitate administration. The chapter covers:

• GitHub scopes and namespaces
• Structuring GitHub teams
• Role-based access
• Custom roles
• Outside Collaborators

Chapter 23: Transform Your Enterprise

The last chapter puts all the pieces together. The book gives you a lot of tools that you can use to drive a successful transformation and to gain developer velocity. But only if all pieces are put together the transformation will succeed. The chapter will explain, why many transformations fail, and what you shoud do to make your transformation a success.

We will cover the following topics:

• Why many transformations fail
• Start with WHY
• Data-driven transformation