How do you implement backpressure in Go to prevent overloading downstream systems?

// Pattern 1: bounded channel — natural backpressure
func pipeline(ctx context.Context, input <-chan Item) {
    output := make(chan ProcessedItem, 100) // backpressure kicks in at 100

    go func() {
        defer close(output)
        for item := range input {
            result := process(item)
            select {
            case output <- result: // blocks if consumer is slow
            case <-ctx.Done(): return
            }
        }
    }()

    for item := range output {
        writeToDatabase(item) // slow consumer — pressure propagates upstream
    }
}

// Pattern 2: rate limiter (golang.org/x/time/rate — token bucket)
limiter := rate.NewLimiter(rate.Limit(100), 10) // 100 req/s, burst 10

func rateLimitedHandler(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "429 Too Many Requests", http.StatusTooManyRequests)
        return
    }
    // ... handle request
}

// Pattern 3: blocking acquire with context
if err := limiter.Wait(ctx); err != nil {
    return err // backpressure: context expired waiting for a token
}

// Pattern 4: non-blocking drop (best-effort)
select {
case queue <- item: // queue has space
default:            // queue full — drop or return 429
    log.Println("dropping item — queue full")
}