Managing Feature Flags in Deployed Services

In this lesson, you will learn how to decouple code deployment from feature release by implementing dynamic feature flags in your C# services without triggering a new container rollout.

The Problem with Immutable Deployments

In containerized environments, your code is typically baked into an immutable image. Traditionally, if you want to disable a buggy feature or roll out a beta, you would change a configuration file, rebuild the image, and redeploy. This is slow, risky, and resource-intensive. Feature flagging shifts this responsibility from the deployment pipeline to the application runtime.

Implementing Dynamic Toggles

To achieve this, we use a provider pattern that fetches state from an external, centralized source—such as a database, a Redis cache, or a managed configuration service—at runtime. By injecting a IFeatureManager into your services, your code can branch logic based on the live state of a toggle.

public class PaymentService
{
    private readonly IFeatureManager _featureManager;

    public PaymentService(IFeatureManager featureManager)
    {
        _featureManager = featureManager;
    }

    public async Task ProcessPayment(decimal amount)
    {
        // Toggle behavior without redeploying the container
        if (await _featureManager.IsEnabledAsync("NewPaymentGateway"))
        {
            await _gateway.ExecuteModernFlow(amount);
        }
        else
        {
            await _gateway.ExecuteLegacyFlow(amount);
        }
    }
}

Architectural Considerations

When implementing this in a distributed cluster, you must balance consistency and performance:

1. Caching: Do not query your external configuration provider on every request. Implement a local cache within the pod with a short TTL (Time-To-Live). This ensures that if your configuration service goes down, the application remains stable using the last known good state.
2. Configuration Injection: While you avoid container redeployments, ensure your service still monitors environment variables or ConfigMaps for "bootstrap" settings (like the connection string to the feature management service itself).
3. Graceful Degradation: Always design your code to default to the "Safe/Legacy" state if the feature flag system is unreachable.

By abstracting the feature state, you gain the ability to perform instant rollbacks and targeted canary releases by simply updating a centralized toggle, keeping your cluster state stable and your deployment pipeline focused strictly on code shipping.

Key Takeaway: Feature flags allow you to decouple code deployment from feature activation, enabling runtime configuration changes and instant incident mitigation without modifying your container artifacts.