Introduction

Deploying changes to a production system can be risky, especially when the deployment process itself creates a circular dependency. For example, at GitHub, the very act of deploying to github.com could require github.com to be operational—which is impossible if the site is down. This guide walks you through how to use eBPF (extended Berkeley Packet Filter) to detect and prevent such circular dependencies, based on real techniques used by GitHub. By the end, you'll have a practical approach to hardening your own deployment pipelines.

What You Need

• A Linux system with kernel 4.15+ (eBPF support)
• BCC (BPF Compiler Collection) or bpftrace installed
• Basic knowledge of C or Python (for writing eBPF programs)
• Access to your deployment scripts (can be modified)
• A test environment that mirrors your production setup

Steps to Implement eBPF-Based Deployment Safety

1. Step 1: Identify Circular Dependency Types in Your Deployments

   Before writing any code, analyze your deployment scripts to understand what could cause a circular dependency. The three main types are:

   • Direct dependencies: The script directly accesses a service that it depends on (e.g., downloading from a repository that may be down).
   • Hidden dependencies: A tool called by the script checks for updates from an external service, blocking or failing if unreachable.
   • Transient dependencies: The script calls an internal API that in turn tries to reach a service that is also affected by the outage.

   Document each potential source of failure. This step is crucial for knowing what to monitor with eBPF.

2. Step 2: Set Up the eBPF Environment

   Install BCC or bpftrace on your Linux host. For BCC, use package managers or build from source. For example, on Ubuntu:

   sudo apt-get install bpfcc-tools linux-headers-$(uname -r)

   Verify your kernel supports eBPF by running ls /sys/fs/bpf. If the directory exists, you're ready.

3. Step 3: Write an eBPF Program to Monitor Outbound Network Calls

   Start by writing a simple eBPF program that hooks into the connect system call to log all outbound TCP connections made by the deployment process. This will help you spot unwanted calls to external services.

   Example using Python with BCC:

   from bcc import BPF
   bpf_source = """
   #include <uapi/linux/ptrace.h>
   #include <net/sock.h>
   #include <bcc/proto.h>
   
   int trace_connect(struct pt_regs *ctx, struct sockaddr_in *addr)
   {
       u32 pid = bpf_get_current_pid_tgid();
       if (pid != TARGET_PID) return 0;
       bpf_trace_printk("connect to %s:%d\\n", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));
       return 0;
   }
   """
   b = BPF(text=bpf_source)
   b.attach_kprobe(event="tcp_v4_connect", fn_name="trace_connect")
   b.trace_print()

   Replace TARGET_PID with the PID of your deployment script. Run this in your test environment while executing a typical deploy. Capture all connection attempts.

4. Step 4: Block Problematic Calls Using eBPF (Optional)

   Once you identify patterns that create circular dependencies, you can extend your eBPF program to block those calls. For instance, reject any connection to github.com during a deploy (except for emergency fallback).

   

   Use a blacklist of domains or IP ranges. In the eBPF program, return a nonzero value (e.g., -EACCES) to refuse the connection. Be careful: blocking can break legitimate operations, so start with monitoring only.

5. Step 5: Integrate the eBPF Program into Your Deployment Pipeline

   Modify your deployment scripts to load the eBPF program at the start of the deploy and unload it when finished. Use a wrapper script that

   1. Starts the eBPF monitor (or blocker) in the background.
   2. Runs the actual deployment.
   3. Checks logs for any blocked/monitored calls.
   4. Terminates the eBPF program.

   Example pseudocode:

   #!/bin/bash
   bpf_tool monitor_deploy &
   MONITOR_PID=$!
   ./deploy_script.sh
   # Capture results
   cat /sys/kernel/debug/tracing/trace | grep deploy
   kill $MONITOR_PID

6. Step 6: Test Thoroughly and Iterate

   Run your altered deployment in a non-production environment. Verify that:

   • No circular dependencies are triggered.
   • The deployment completes successfully.
   • No false positives block necessary functions.

   Tweak the eBPF program's filters as needed. Gradually roll out to production, monitoring dashboards for anomalies.

Tips for Success

• Start with monitoring, not blocking. Understand normal patterns first; then add restrictions.
• Use kprobes judiciously. Hooking into too many system calls can degrade performance.
• Maintain a fallback mechanism. If your eBPF program itself fails, ensure the deployment can still proceed without it.
• Document your dependency map. Share with your team to align on what should never be called during deploys.
• Combine with traditional safeguards like offline mirrors and rollback assets, as GitHub does with its code mirror.

By following these steps, you can leverage the power of eBPF to make your deployment pipelines more resilient against circular dependencies—just like GitHub does for its own infrastructure.