Mastering Microservices: A Complete Guide to Modern Deployment and Release Patterns#

1
graph TB
2
    subgraph "Load Balancer"
3
        LB[Load Balancer/Ingress]
4
    end
5

6
    subgraph "Blue Environment (Production)"
7
        B1[App v1.0]
8
        B2[App v1.0]
9
        B3[App v1.0]
10
        BDB[(Database)]
11
    end
12

13
    subgraph "Green Environment (Staging)"
14
        G1[App v2.0]
15
        G2[App v2.0]
16
        G3[App v2.0]
17
        GDB[(Database)]
18
    end
19

20
    subgraph "Shared Services"
21
        Cache[(Redis Cache)]
22
        Queue[Message Queue]
23
    end
24

25
    Users --> LB
26
    LB -->|100% Traffic| B1
27
    LB -->|100% Traffic| B2
28
    LB -->|100% Traffic| B3
29

30
    LB -.->|0% Traffic| G1
31
    LB -.->|0% Traffic| G2
32
    LB -.->|0% Traffic| G3
33

34
    B1 --> BDB
35
    B2 --> BDB
36
    B3 --> BDB
37

38
    G1 --> GDB
39
    G2 --> GDB
40
    G3 --> GDB
41

42
    B1 --> Cache
43
    B2 --> Cache
44
    B3 --> Cache
45
    G1 --> Cache
46
    G2 --> Cache
47
    G3 --> Cache
48

49
    classDef blue fill:#e3f2fd
50
    classDef green fill:#e8f5e8
51
    classDef shared fill:#fff3e0
52

53
    class B1,B2,B3,BDB blue
54
    class G1,G2,G3,GDB green
55
    class Cache,Queue shared

1
sequenceDiagram
2
    participant Dev as Developer
3
    participant Git as Git Repository
4
    participant CI as CI/CD Pipeline
5
    participant Argo as Argo Rollouts
6
    participant K8s as Kubernetes
7
    participant Monitor as Monitoring
8

9
    Dev->>Git: Push v2.0.0 code
10
    Git->>CI: Trigger build pipeline
11
    CI->>CI: Run tests & security scans
12
    CI->>CI: Build container image
13
    CI->>Git: Update deployment manifest
14

15
    Git->>Argo: Detect manifest change
16
    Argo->>K8s: Deploy to Green environment
17
    K8s->>Monitor: Start health checks
18

19
    Monitor->>Argo: Health checks passing
20
    Argo->>Argo: Run pre-promotion analysis
21
    Argo->>Dev: Request manual approval
22

23
    Dev->>Argo: Approve promotion
24
    Argo->>K8s: Switch traffic to Green
25
    K8s->>Monitor: Monitor post-deployment
26

27
    alt Success
28
        Monitor->>Argo: All metrics healthy
29
        Argo->>K8s: Scale down Blue environment
30
    else Failure
31
        Monitor->>Argo: Metrics degraded
32
        Argo->>K8s: Rollback to Blue
33
        Argo->>Dev: Send failure notification
34
    end

1
graph TB
2
    subgraph "Istio Service Mesh"
3
        subgraph "Gateway"
4
            IGW[Istio Gateway]
5
        end
6

7
        subgraph "Virtual Service"
8
            VS[Traffic Splitting Rules]
9
        end
10

11
        subgraph "Destination Rules"
12
            DR[Version Subsets]
13
        end
14

15
        subgraph "Production Pods"
16
            subgraph "Version 1 (90%)"
17
                V1P1[Pod v1]
18
                V1P2[Pod v1]
19
                V1P3[Pod v1]
20
                V1P4[Pod v1]
21
                V1P5[Pod v1]
22
                V1P6[Pod v1]
23
            end
24

25
            subgraph "Version 2 Canary (10%)"
26
                V2P1[Pod v2]
27
                V2P2[Pod v2]
28
            end
29
        end
30

31
        subgraph "Monitoring"
32
            Prom[Prometheus]
33
            Graf[Grafana]
34
            Jaeger[Jaeger Tracing]
35
        end
36

37
        subgraph "Automation"
38
            Flagger[Flagger Controller]
39
        end
40
    end
41

42
    Users --> IGW
43
    IGW --> VS
44
    VS -->|90%| V1P1
45
    VS -->|90%| V1P2
46
    VS -->|90%| V1P3
47
    VS -->|90%| V1P4
48
    VS -->|90%| V1P5
49
    VS -->|90%| V1P6
50
    VS -->|10%| V2P1
51
    VS -->|10%| V2P2
52

53
    V1P1 --> Prom
54
    V1P2 --> Prom
55
    V2P1 --> Prom
56
    V2P2 --> Prom
57

58
    Flagger --> VS
59
    Flagger --> Prom
60
    Prom --> Graf
61

62
    classDef v1 fill:#e3f2fd
63
    classDef v2 fill:#ffebee
64
    classDef control fill:#f3e5f5
65

66
    class V1P1,V1P2,V1P3,V1P4,V1P5,V1P6 v1
67
    class V2P1,V2P2 v2
68
    class VS,DR,Flagger control

1
# Gateway configuration
2
apiVersion: networking.istio.io/v1beta1
3
kind: Gateway
4
metadata:
5
  name: user-service-gateway
6
  namespace: production
7
spec:
8
  selector:
9
    istio: ingressgateway
10
  servers:
11
    - port:
12
        number: 80
13
        name: http
14
        protocol: HTTP
15
      hosts:
16
        - api.example.com
17

18
---
19
# Destination rule defining version subsets
20
apiVersion: networking.istio.io/v1beta1
21
kind: DestinationRule
22
metadata:
23
  name: user-service-dr
24
  namespace: production
25
spec:
26
  host: user-service
27
  subsets:
28
    - name: v1
29
      labels:
30
        version: v1
31
    - name: v2
32
      labels:
33
        version: v2
34
  trafficPolicy:
35
    loadBalancer:
36
      simple: LEAST_CONN
37
    connectionPool:
38
      tcp:
39
        maxConnections: 100
40
      http:
41
        http1MaxPendingRequests: 50
42
        maxRequestsPerConnection: 2
43

44
---
45
# Virtual service with traffic splitting
46
apiVersion: networking.istio.io/v1beta1
47
kind: VirtualService
48
metadata:
49
  name: user-service-vs
50
  namespace: production
51
spec:
52
  hosts:
53
    - api.example.com
54
  gateways:
55
    - user-service-gateway
56
  http:
57
    - match:
58
        - uri:
59
            prefix: /api/users
60
      route:
61
        - destination:
62
            host: user-service
63
            subset: v1
64
          weight: 90
65
        - destination:
66
            host: user-service
67
            subset: v2
68
          weight: 10
69
      timeout: 30s
70
      retries:
71
        attempts: 3
72
        perTryTimeout: 10s

1
# Flagger canary deployment
2
apiVersion: flagger.app/v1beta1
3
kind: Canary
4
metadata:
5
  name: user-service
6
  namespace: production
7
spec:
8
  targetRef:
9
    apiVersion: apps/v1
10
    kind: Deployment
11
    name: user-service
12
  progressDeadlineSeconds: 60
13
  service:
14
    port: 80
15
    targetPort: 8080
16
    gateways:
17
      - user-service-gateway
18
    hosts:
19
      - api.example.com
20
  analysis:
21
    interval: 1m
22
    threshold: 5
23
    maxWeight: 50
24
    stepWeight: 10
25
    metrics:
26
      - name: request-success-rate
27
        threshold: 99
28
        interval: 1m
29
      - name: request-duration
30
        threshold: 500
31
        interval: 1m
32
      - name: error-rate
33
        threshold: 1
34
        interval: 1m
35
    webhooks:
36
      - name: load-test
37
        url: http://load-tester.test/
38
        timeout: 5s
39
        metadata:
40
          cmd: "hey -z 10m -q 10 -c 2 http://api.example.com/api/users"
41
      - name: integration-test
42
        url: http://integration-tester.test/
43
        timeout: 30s
44
        metadata:
45
          type: bash
46
          cmd: "curl -s http://api.example.com/api/users/health | grep OK"
47
  provider: istio

1
gantt
2
    title Canary Deployment Timeline
3
    dateFormat X
4
    axisFormat %s
5

6
    section Traffic Split
7
    0% Canary (Baseline)     :0, 300
8
    10% Canary (Initial)     :300, 600
9
    20% Canary               :600, 900
10
    30% Canary               :900, 1200
11
    50% Canary (Half Split)  :1200, 1500
12
    100% Canary (Complete)   :1500, 1800
13

14
    section Health Checks
15
    Readiness Probes         :0, 1800
16
    Success Rate Monitor     :300, 1800
17
    Latency Monitor          :300, 1800
18
    Error Rate Monitor       :300, 1800
19

20
    section Automated Actions
21
    Initial Deployment        :0, 300
22
    Traffic Increment         :300, 1500
23
    Promotion Decision        :1500, 1650
24
    Cleanup Old Version       :1650, 1800

1
sequenceDiagram
2
    participant User as Users
3
    participant LB as Load Balancer
4
    participant K8s as Kubernetes Controller
5
    participant RS1 as ReplicaSet v1
6
    participant RS2 as ReplicaSet v2
7
    participant Pods1 as Pods v1
8
    participant Pods2 as Pods v2
9

10
    Note over User,Pods2: Initial State: 6 pods running v1
11
    User->>LB: Traffic (100%)
12
    LB->>Pods1: Route to 6 v1 pods
13

14
    Note over K8s,Pods2: Rolling Update Initiated
15
    K8s->>RS2: Create ReplicaSet v2
16
    K8s->>RS2: Scale up to 2 pods (maxSurge=2)
17
    RS2->>Pods2: Create 2 v2 pods
18

19
    Note over Pods2: Wait for readiness probes
20
    Pods2->>K8s: Ready signals
21

22
    K8s->>RS1: Scale down by 1 pod
23
    RS1->>Pods1: Terminate 1 v1 pod
24

25
    Note over User,Pods2: Traffic: 5 v1 + 2 v2 pods
26
    User->>LB: Traffic (100%)
27
    LB->>Pods1: Route to 5 v1 pods
28
    LB->>Pods2: Route to 2 v2 pods
29

30
    K8s->>RS2: Scale up to 4 pods
31
    RS2->>Pods2: Create 2 more v2 pods
32
    Pods2->>K8s: Ready signals
33

34
    K8s->>RS1: Scale down by 2 pods
35
    RS1->>Pods1: Terminate 2 v1 pods
36

37
    Note over User,Pods2: Traffic: 3 v1 + 4 v2 pods
38

39
    K8s->>RS2: Scale up to 6 pods
40
    RS2->>Pods2: Create 2 more v2 pods
41
    Pods2->>K8s: Ready signals
42

43
    K8s->>RS1: Scale down to 0
44
    RS1->>Pods1: Terminate remaining v1 pods
45

46
    Note over User,Pods2: Final State: 6 pods running v2
47
    User->>LB: Traffic (100%)
48
    LB->>Pods2: Route to 6 v2 pods

1
# Deployment with rolling update strategy
2
apiVersion: apps/v1
3
kind: Deployment
4
metadata:
5
  name: user-service
6
  namespace: production
7
  labels:
8
    app: user-service
9
    version: v2.0.0
10
spec:
11
  replicas: 6
12
  strategy:
13
    type: RollingUpdate
14
    rollingUpdate:
15
      maxSurge: 2 # Allow 2 extra pods during update
16
      maxUnavailable: 1 # Max 1 pod unavailable at a time
17
  minReadySeconds: 30 # Wait 30s before considering pod ready
18
  progressDeadlineSeconds: 600 # 10min timeout for rollout
19
  revisionHistoryLimit: 5 # Keep 5 previous versions
20
  selector:
21
    matchLabels:
22
      app: user-service
23
  template:
24
    metadata:
25
      labels:
26
        app: user-service
27
        version: v2.0.0
28
    spec:
29
      containers:
30
        - name: user-service
31
          image: myregistry/user-service:v2.0.0
32
          ports:
33
            - containerPort: 8080
34
              name: http
35
          resources:
36
            requests:
37
              cpu: 200m
38
              memory: 256Mi
39
            limits:
40
              cpu: 1000m
41
              memory: 1Gi
42
          env:
43
            - name: ENV
44
              value: "production"
45
            - name: DATABASE_URL
46
              valueFrom:
47
                secretKeyRef:
48
                  name: database-credentials
49
                  key: url
50
          # Comprehensive health checks
51
          readinessProbe:
52
            httpGet:
53
              path: /health/ready
54
              port: 8080
55
              httpHeaders:
56
                - name: Custom-Header
57
                  value: health-check
58
            initialDelaySeconds: 15
59
            periodSeconds: 10
60
            timeoutSeconds: 5
61
            successThreshold: 2
62
            failureThreshold: 3
63
          livenessProbe:
64
            httpGet:
65
              path: /health/live
66
              port: 8080
67
            initialDelaySeconds: 60
68
            periodSeconds: 30
69
            timeoutSeconds: 10
70
            failureThreshold: 3
71
          # Startup probe for slow-starting applications
72
          startupProbe:
73
            httpGet:
74
              path: /health/startup
75
              port: 8080
76
            initialDelaySeconds: 10
77
            periodSeconds: 5
78
            timeoutSeconds: 3
79
            failureThreshold: 12 # 60 seconds total
80
          # Graceful shutdown
81
          lifecycle:
82
            preStop:
83
              exec:
84
                command: ["/bin/sh", "-c", "sleep 15"]
85
          # Security context
86
          securityContext:
87
            runAsNonRoot: true
88
            runAsUser: 1000
89
            allowPrivilegeEscalation: false
90
            readOnlyRootFilesystem: true
91
            capabilities:
92
              drop:
93
                - ALL
94
      # Pod security and scheduling
95
      securityContext:
96
        fsGroup: 1000
97
      terminationGracePeriodSeconds: 30
98
      affinity:
99
        podAntiAffinity:
100
          preferredDuringSchedulingIgnoredDuringExecution:
101
            - weight: 100
102
              podAffinityTerm:
103
                labelSelector:
104
                  matchExpressions:
105
                    - key: app
106
                      operator: In
107
                      values:
108
                        - user-service
109
                topologyKey: kubernetes.io/hostname
110

111
---
112
# Service for rolling updates
113
apiVersion: v1
114
kind: Service
115
metadata:
116
  name: user-service
117
  namespace: production
118
  labels:
119
    app: user-service
120
spec:
121
  selector:
122
    app: user-service
123
  ports:
124
    - port: 80
125
      targetPort: 8080
126
      protocol: TCP
127
      name: http
128
  type: ClusterIP
129

130
---
131
# Pod Disruption Budget
132
apiVersion: policy/v1
133
kind: PodDisruptionBudget
134
metadata:
135
  name: user-service-pdb
136
  namespace: production
137
spec:
138
  minAvailable: 4 # Always keep at least 4 pods running
139
  selector:
140
    matchLabels:
141
      app: user-service

1
// Node.js health check endpoints
2
const express = require("express");
3
const app = express();
4

5
let isReady = false;
6
let isLive = true;
7
let startupComplete = false;
8

9
// Simulate application startup
10
setTimeout(() => {
11
  startupComplete = true;
12
  isReady = true;
13
}, 10000); // 10 second startup time
14

15
// Startup probe - for slow-starting applications
16
app.get("/health/startup", (req, res) => {
17
  if (startupComplete) {
18
    res.status(200).json({
19
      status: "started",
20
      timestamp: new Date().toISOString(),
21
    });
22
  } else {
23
    res.status(503).json({
24
      status: "starting",
25
      timestamp: new Date().toISOString(),
26
    });
27
  }
28
});
29

30
// Readiness probe - ready to receive traffic
31
app.get("/health/ready", (req, res) => {
32
  // Check dependencies (database, external services)
33
  const checks = {
34
    database: checkDatabase(),
35
    redis: checkRedis(),
36
    externalAPI: checkExternalAPI(),
37
  };
38

39
  const allHealthy = Object.values(checks).every(check => check);
40

41
  if (isReady && allHealthy) {
42
    res.status(200).json({
43
      status: "ready",
44
      checks,
45
      timestamp: new Date().toISOString(),
46
    });
47
  } else {
48
    res.status(503).json({
49
      status: "not ready",
50
      checks,
51
      timestamp: new Date().toISOString(),
52
    });
53
  }
54
});
55

56
// Liveness probe - application is healthy
57
app.get("/health/live", (req, res) => {
58
  if (isLive) {
59
    res.status(200).json({
60
      status: "alive",
61
      uptime: process.uptime(),
62
      memory: process.memoryUsage(),
63
      timestamp: new Date().toISOString(),
64
    });
65
  } else {
66
    res.status(503).json({
67
      status: "unhealthy",
68
      timestamp: new Date().toISOString(),
69
    });
70
  }
71
});
72

73
function checkDatabase() {
74
  // Implement actual database connectivity check
75
  return Math.random() > 0.1; // 90% success rate for demo
76
}
77

78
function checkRedis() {
79
  // Implement actual Redis connectivity check
80
  return Math.random() > 0.05; // 95% success rate for demo
81
}
82

83
function checkExternalAPI() {
84
  // Implement actual external API check
85
  return Math.random() > 0.15; // 85% success rate for demo
86
}
87

88
// Graceful shutdown handler
89
process.on("SIGTERM", () => {
90
  console.log("SIGTERM received, shutting down gracefully");
91
  isReady = false; // Stop accepting new requests
92

93
  setTimeout(() => {
94
    isLive = false; // Mark as unhealthy
95
    process.exit(0);
96
  }, 15000); // Wait 15 seconds for existing requests
97
});
98

99
app.listen(8080, () => {
100
  console.log("Health check server running on port 8080");
101
});

1
graph TB
2
    subgraph "Client Applications"
3
        Web[Web App]
4
        Mobile[Mobile App]
5
        API[API Gateway]
6
    end
7

8
    subgraph "Feature Flag Service"
9
        FFS[Feature Flag Server]
10
        Admin[Admin Dashboard]
11
        SDK[Client SDKs]
12
    end
13

14
    subgraph "Configuration Store"
15
        DB[(Flag Database)]
16
        Cache[(Redis Cache)]
17
        CDN[Edge Cache/CDN]
18
    end
19

20
    subgraph "User Context"
21
        UserDB[(User Database)]
22
        Segments[User Segments]
23
        Analytics[Analytics Engine]
24
    end
25

26
    subgraph "Application Services"
27
        UserSvc[User Service]
28
        PaymentSvc[Payment Service]
29
        OrderSvc[Order Service]
30
    end
31

32
    subgraph "Monitoring & Observability"
33
        Metrics[Metrics Store]
34
        Logs[Log Aggregation]
35
        Alerts[Alert Manager]
36
    end
37

38
    Web --> SDK
39
    Mobile --> SDK
40
    API --> SDK
41

42
    SDK --> FFS
43
    Admin --> FFS
44

45
    FFS --> DB
46
    FFS --> Cache
47
    SDK --> CDN
48

49
    FFS --> UserDB
50
    FFS --> Segments
51
    FFS --> Analytics
52

53
    UserSvc --> SDK
54
    PaymentSvc --> SDK
55
    OrderSvc --> SDK
56

57
    FFS --> Metrics
58
    FFS --> Logs
59
    FFS --> Alerts
60

61
    classDef client fill:#e3f2fd
62
    classDef service fill:#e8f5e8
63
    classDef data fill:#fff3e0
64
    classDef monitor fill:#fce4ec
65

66
    class Web,Mobile,API client
67
    class FFS,Admin,SDK service
68
    class DB,Cache,CDN,UserDB data
69
    class Metrics,Logs,Alerts monitor

1
// Feature flag service implementation
2
interface FeatureFlag {
3
  key: string;
4
  name: string;
5
  description: string;
6
  enabled: boolean;
7
  rolloutPercentage: number;
8
  userSegments: string[];
9
  environmentRules: Record<string, any>;
10
  constraints: Constraint[];
11
  createdAt: Date;
12
  updatedAt: Date;
13
}
14

15
interface User {
16
  id: string;
17
  email: string;
18
  segments: string[];
19
  attributes: Record<string, any>;
20
}
21

22
interface Constraint {
23
  type: "user_id" | "segment" | "attribute" | "percentage";
24
  operator: "in" | "not_in" | "equals" | "greater_than" | "less_than";
25
  values: any[];
26
}
27

28
class FeatureFlagService {
29
  private flags: Map<string, FeatureFlag> = new Map();
30
  private cache: Map<string, boolean> = new Map();
31

32
  constructor(
33
    private database: Database,
34
    private analytics: AnalyticsService,
35
    private logger: Logger
36
  ) {}
37

38
  async isEnabled(
39
    flagKey: string,
40
    user: User,
41
    context?: any
42
  ): Promise<boolean> {
43
    const cacheKey = `${flagKey}:${user.id}`;
44

45
    // Check cache first
46
    if (this.cache.has(cacheKey)) {
47
      return this.cache.get(cacheKey)!;
48
    }
49

50
    const flag = await this.getFlag(flagKey);
51
    if (!flag || !flag.enabled) {
52
      this.cache.set(cacheKey, false);
53
      return false;
54
    }
55

56
    const result = await this.evaluateFlag(flag, user, context);
57

58
    // Cache result for 5 minutes
59
    this.cache.set(cacheKey, result);
60
    setTimeout(() => this.cache.delete(cacheKey), 5 * 60 * 1000);
61

62
    // Track flag evaluation
63
    this.analytics.track("feature_flag_evaluated", {
64
      flagKey,
65
      userId: user.id,
66
      result,
67
      timestamp: new Date(),
68
    });
69

70
    return result;
71
  }
72

73
  private async evaluateFlag(
74
    flag: FeatureFlag,
75
    user: User,
76
    context?: any
77
  ): Promise<boolean> {
78
    // Check constraints
79
    for (const constraint of flag.constraints) {
80
      if (!this.evaluateConstraint(constraint, user, context)) {
81
        return false;
82
      }
83
    }
84

85
    // Check user segments
86
    if (flag.userSegments.length > 0) {
87
      const hasSegment = flag.userSegments.some(segment =>
88
        user.segments.includes(segment)
89
      );
90
      if (!hasSegment) {
91
        return false;
92
      }
93
    }
94

95
    // Check rollout percentage
96
    if (flag.rolloutPercentage < 100) {
97
      const userHash = this.hashUser(user.id, flag.key);
98
      const userPercentile = userHash % 100;
99
      return userPercentile < flag.rolloutPercentage;
100
    }
101

102
    return true;
103
  }
104

105
  private evaluateConstraint(
106
    constraint: Constraint,
107
    user: User,
108
    context?: any
109
  ): boolean {
110
    switch (constraint.type) {
111
      case "user_id":
112
        return this.evaluateOperator(
113
          constraint.operator,
114
          user.id,
115
          constraint.values
116
        );
117

118
      case "segment":
119
        return this.evaluateOperator(
120
          constraint.operator,
121
          user.segments,
122
          constraint.values
123
        );
124

125
      case "attribute":
126
        const attributeValue = user.attributes[constraint.values[0]];
127
        return this.evaluateOperator(
128
          constraint.operator,
129
          attributeValue,
130
          constraint.values.slice(1)
131
        );
132

133
      case "percentage":
134
        const userHash = this.hashUser(user.id, "percentage");
135
        const percentile = userHash % 100;
136
        return percentile < constraint.values[0];
137

138
      default:
139
        return false;
140
    }
141
  }
142

143
  private evaluateOperator(
144
    operator: string,
145
    userValue: any,
146
    constraintValues: any[]
147
  ): boolean {
148
    switch (operator) {
149
      case "in":
150
        return constraintValues.includes(userValue);
151
      case "not_in":
152
        return !constraintValues.includes(userValue);
153
      case "equals":
154
        return userValue === constraintValues[0];
155
      case "greater_than":
156
        return userValue > constraintValues[0];
157
      case "less_than":
158
        return userValue < constraintValues[0];
159
      default:
160
        return false;
161
    }
162
  }
163

164
  private hashUser(userId: string, salt: string): number {
165
    // Simple hash function for consistent user bucketing
166
    let hash = 0;
167
    const str = userId + salt;
168
    for (let i = 0; i < str.length; i++) {
169
      const char = str.charCodeAt(i);
170
      hash = (hash << 5) - hash + char;
171
      hash = hash & hash; // Convert to 32-bit integer
172
    }
173
    return Math.abs(hash);
174
  }
175

176
  async updateRolloutPercentage(
177
    flagKey: string,
178
    percentage: number
179
  ): Promise<void> {
180
    const flag = await this.getFlag(flagKey);
181
    if (!flag) throw new Error(`Flag ${flagKey} not found`);
182

183
    flag.rolloutPercentage = percentage;
184
    flag.updatedAt = new Date();
185

186
    await this.database.updateFlag(flag);
187

188
    // Clear cache to force re-evaluation
189
    this.cache.clear();
190

191
    this.logger.info(
192
      `Updated rollout percentage for ${flagKey} to ${percentage}%`
193
    );
194
  }
195

196
  private async getFlag(flagKey: string): Promise<FeatureFlag | null> {
197
    if (this.flags.has(flagKey)) {
198
      return this.flags.get(flagKey)!;
199
    }
200

201
    const flag = await this.database.getFlag(flagKey);
202
    if (flag) {
203
      this.flags.set(flagKey, flag);
204
    }
205

206
    return flag;
207
  }
208
}

1
gantt
2
    title Progressive Feature Rollout Strategy
3
    dateFormat X
4
    axisFormat %d/%m
5

6
    section Development
7
    Feature Development        :0, 7
8
    Unit Testing               :5, 10
9
    Integration Testing        :8, 12
10

11
    section Internal Rollout
12
    Team Testing (0.1%)        :12, 15
13
    Beta Users (1%)            :15, 18
14
    Power Users (5%)           :18, 21
15

16
    section Progressive Rollout
17
    Early Adopters (10%)       :21, 25
18
    Segment A (25%)            :25, 28
19
    Segment B (50%)            :28, 32
20
    Full Rollout (100%)        :32, 35
21

22
    section Monitoring
23
    Error Rate Monitoring      :12, 40
24
    Performance Monitoring     :12, 40
25
    User Feedback Collection   :12, 40
26
    Business Metrics Tracking  :21, 40

1
graph TB
2
    subgraph "Git Repositories"
3
        AppRepo[Application Code]
4
        ConfigRepo[Configuration Repo]
5
        InfraRepo[Infrastructure Repo]
6
        EnvRepo[Environment Configs]
7
    end
8

9
    subgraph "CI/CD Pipeline"
10
        CI[CI Pipeline]
11
        Registry[Container Registry]
12
        Scanner[Security Scanner]
13
    end
14

15
    subgraph "GitOps Controllers"
16
        ArgoCD[ArgoCD Controller]
17
        Flux[Flux Controller]
18
        Tekton[Tekton Pipelines]
19
    end
20

21
    subgraph "Kubernetes Clusters"
22
        subgraph "Development"
23
            DevCluster[Dev Cluster]
24
            DevApps[Applications]
25
        end
26

27
        subgraph "Staging"
28
            StageCluster[Staging Cluster]
29
            StageApps[Applications]
30
        end
31

32
        subgraph "Production"
33
            ProdCluster[Prod Cluster]
34
            ProdApps[Applications]
35
        end
36
    end
37

38
    subgraph "Observability"
39
        Prometheus[Prometheus]
40
        Grafana[Grafana]
41
        AlertManager[Alert Manager]
42
    end
43

44
    AppRepo --> CI
45
    CI --> Scanner
46
    CI --> Registry
47
    CI --> ConfigRepo
48

49
    ConfigRepo --> ArgoCD
50
    ConfigRepo --> Flux
51
    InfraRepo --> ArgoCD
52
    EnvRepo --> ArgoCD
53

54
    ArgoCD --> DevCluster
55
    ArgoCD --> StageCluster
56
    ArgoCD --> ProdCluster
57

58
    Flux --> DevCluster
59
    Flux --> StageCluster
60

61
    DevApps --> Prometheus
62
    StageApps --> Prometheus
63
    ProdApps --> Prometheus
64

65
    Prometheus --> Grafana
66
    Prometheus --> AlertManager
67

68
    classDef git fill:#f9f9f9
69
    classDef ci fill:#e3f2fd
70
    classDef gitops fill:#e8f5e8
71
    classDef cluster fill:#fff3e0
72
    classDef monitor fill:#fce4ec
73

74
    class AppRepo,ConfigRepo,InfraRepo,EnvRepo git
75
    class CI,Registry,Scanner ci
76
    class ArgoCD,Flux,Tekton gitops
77
    class DevCluster,StageCluster,ProdCluster cluster
78
    class Prometheus,Grafana,AlertManager monitor