# BLUE Deployment: the version serving today.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bookings-api-blue
  namespace: rutas-norte-pro
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: bookings-api
      rutasnorte.example/colour: blue
  template:
    metadata:
      labels:
        app.kubernetes.io/name: bookings-api
        rutasnorte.example/colour: blue    # ← the label that decides everything
        rutasnorte.example/version: "2.7.0"
    spec:
      # ... identical to the Deployment in 11-01
      containers:
        - name: api
          image: registry.rutasnorte.example/rutasnorte/bookings-api@sha256:3f9c1b7e5a04c2d8f61b93ae7c05d2419e8f6ab3c4d5e6f708192a3b4c5d6e7f
---
# GREEN Deployment: the candidate version.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bookings-api-green
  namespace: rutas-norte-pro
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: bookings-api
      rutasnorte.example/colour: green
  template:
    metadata:
      labels:
        app.kubernetes.io/name: bookings-api
        rutasnorte.example/colour: green
        rutasnorte.example/version: "2.8.0"
    spec:
      containers:
        - name: api
          image: registry.rutasnorte.example/rutasnorte/bookings-api@sha256:9a8b7c6d5e4f30291a8b7c6d5e4f30291a8b7c6d5e4f30291a8b7c6d5e4f3029
---
# PRODUCTION Service: the one the Ingress uses. Its selector is the switch.
apiVersion: v1
kind: Service
metadata:
  name: bookings-api
  namespace: rutas-norte-pro
spec:
  selector:
    app.kubernetes.io/name: bookings-api
    rutasnorte.example/colour: blue      # ← change here = release
  ports:
    - { name: http, port: 80, targetPort: http }
---
# PREVIEW Service: always points at green, with no user traffic.
apiVersion: v1
kind: Service
metadata:
  name: bookings-api-preview
  namespace: rutas-norte-pro
spec:
  selector:
    app.kubernetes.io/name: bookings-api
    rutasnorte.example/colour: green
  ports:
    - { name: http, port: 80, targetPort: http }
---
# Preview Ingress: internal URL for validating the candidate.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: bookings-api-preview
  namespace: rutas-norte-pro
  annotations:
    # Corporate network only: this is not a public URL.
    nginx.ingress.kubernetes.io/whitelist-source-range: "203.0.113.0/24"
    cert-manager.io/cluster-issuer: letsencrypt-production
spec:
  ingressClassName: nginx
  tls:
    - hosts: ["api-preview.rutasnorte.example"]
      secretName: api-preview-tls
  rules:
    - host: api-preview.rutasnorte.example
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: bookings-api-preview, port: { name: http } }

# --- 1. Deploy the candidate to green (no user traffic) ---
kubectl -n rutas-norte-pro set image deploy/bookings-api-green \
  api=registry.rutasnorte.example/rutasnorte/bookings-api@sha256:9a8b7c6d...
kubectl -n rutas-norte-pro rollout status deploy/bookings-api-green --timeout=10m
kubectl -n rutas-norte-pro scale deploy/bookings-api-green --replicas=8

# --- 2. Validate with no real traffic ---
# Smoke tests against the preview URL
npm run test:smoke -- --base-url https://api-preview.rutasnorte.example
# A gentle load test to rule out obvious performance regressions
k6 run --vus 40 --duration 5m tests/preview-load.js
# Manual check of the full purchase flow by product

# --- 3. Switch over (this is the release: it takes milliseconds) ---
kubectl -n rutas-norte-pro patch svc bookings-api \
  -p '{"spec":{"selector":{"rutasnorte.example/colour":"green"}}}'

# --- 4. Watch ---
watch -n5 'curl -sG http://prometheus.rutas-norte.example/api/v1/query \
  --data-urlencode "query=sum(rate(rutasnorte_requests_total{code=~\"5..\"}[2m]))
                          / sum(rate(rutasnorte_requests_total[2m]))" | jq -r ".data.result[0].value[1]"'

# --- 5. Roll back, if needed (seconds) ---
kubectl -n rutas-norte-pro patch svc bookings-api \
  -p '{"spec":{"selector":{"rutasnorte.example/colour":"blue"}}}'

-- ===== Migration 1: EXPAND (compatible with 2.7.0) =====
-- Add, never rename or drop.
ALTER TABLE bookings ADD COLUMN seat_number integer;

-- Copy the history in batches, without locking the table.
UPDATE bookings SET seat_number = seat
 WHERE seat_number IS NULL AND id IN (SELECT id FROM bookings WHERE seat_number IS NULL LIMIT 5000);
-- (repeated until exhausted; in production, via a batch Job)

-- Trigger that keeps both columns in sync while versions that
-- write to one or the other coexist.
CREATE OR REPLACE FUNCTION sync_seat_number() RETURNS trigger AS $$
BEGIN
  IF NEW.seat_number IS NULL THEN NEW.seat_number := NEW.seat; END IF;
  IF NEW.seat IS NULL THEN NEW.seat := NEW.seat_number; END IF;
  RETURN NEW;
END; $$ LANGUAGE plpgsql;

CREATE TRIGGER trg_sync_seat_number
  BEFORE INSERT OR UPDATE ON bookings
  FOR EACH ROW EXECUTE FUNCTION sync_seat_number();

-- ===== Migration 2: CONTRACT (only when NOBODY uses 'seat') =====
-- Weeks later, with the old version fully retired.
DROP TRIGGER trg_sync_seat_number ON bookings;
DROP FUNCTION sync_seat_number();
ALTER TABLE bookings DROP COLUMN seat;
ALTER TABLE bookings ALTER COLUMN seat_number SET NOT NULL;

# 19 stable replicas + 1 canary ≈ 5 % of the traffic
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bookings-api-canary
  namespace: rutas-norte-pro
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: bookings-api
      rutasnorte.example/track: canary
  template:
    metadata:
      labels:
        app.kubernetes.io/name: bookings-api    # the Service selects on this one
        rutasnorte.example/track: canary

# Main Ingress: unchanged from 11-01.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: bookings-api
  namespace: rutas-norte-pro
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-production
spec:
  ingressClassName: nginx
  tls:
    - hosts: ["api.rutasnorte.example"]
      secretName: api-rutasnorte-tls
  rules:
    - host: api.rutasnorte.example
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: bookings-api-stable, port: { name: http } }
---
# CANARY Ingress: same host, different backend, with a weight.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: bookings-api-canary
  namespace: rutas-norte-pro
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-production
    # Enables canary mode for this Ingress.
    nginx.ingress.kubernetes.io/canary: "true"
    # Percentage of traffic that goes to the canary.
    nginx.ingress.kubernetes.io/canary-weight: "5"
    # Escape header: forces the canary for internal testing,
    # regardless of the weight.
    nginx.ingress.kubernetes.io/canary-by-header: "X-Rutasnorte-Canary"
    nginx.ingress.kubernetes.io/canary-by-header-value: "always"
    # Cookie: once assigned, the user stays on their version.
    nginx.ingress.kubernetes.io/canary-by-cookie: "rutasnorte_canary"
spec:
  ingressClassName: nginx
  tls:
    - hosts: ["api.rutasnorte.example"]
      secretName: api-rutasnorte-tls
  rules:
    - host: api.rutasnorte.example          # ← SAME host as the main one
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: bookings-api-canary, port: { name: http } }

# Internal validation aimed at the canary, with 0 % weight
curl -H 'X-Rutasnorte-Canary: always' https://api.rutasnorte.example/schedules?line=BIL-SAN

for WEIGHT in 5 10 25 50 100; do
  kubectl -n rutas-norte-pro annotate ingress bookings-api-canary \
    nginx.ingress.kubernetes.io/canary-weight="$WEIGHT" --overwrite
  echo "Weight at $WEIGHT %. Watching for 10 minutes..."
  sleep 600
  # here somebody looks at Grafana and decides whether to carry on
done

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: bookings-api
  namespace: rutas-norte-pro
spec:
  # replicas is still governed by the HPA, which now points at the Rollout.
  revisionHistoryLimit: 5
  selector:
    matchLabels:
      app.kubernetes.io/name: bookings-api
  # 'template' is identical to the Deployment's in 11-01: same probes,
  # same securityContext, same resources, same topologySpread.
  template:
    metadata:
      labels:
        app.kubernetes.io/name: bookings-api
    spec:
      serviceAccountName: bookings-api
      containers:
        - name: api
          image: registry.rutasnorte.example/rutasnorte/bookings-api@sha256:9a8b7c6d5e4f30291a8b7c6d5e4f30291a8b7c6d5e4f30291a8b7c6d5e4f3029
          # ... the rest identical to 11-01

  strategy:
    canary:
      canaryService: bookings-api-canary      # Services that the controller
      stableService: bookings-api-stable      # relabels automatically
      trafficRouting:
        nginx:
          stableIngress: bookings-api          # creates and manages the canary Ingress
      # Analysis that runs in parallel with the WHOLE progression.
      analysis:
        templates:
          - templateName: bookings-api-analysis
        startingStep: 1        # starts once the first weight is reached
        args:
          - name: canary-service
            value: bookings-api-canary
      steps:
        - setWeight: 5
        - pause: { duration: 10m }     # 10 min with 5 % of the traffic
        - setWeight: 25
        - pause: { duration: 15m }
        - setWeight: 50
        - pause: { duration: 20m }
        - setWeight: 75
        - pause: { duration: 10m }
        # No duration: waits for explicit human approval before 100 %.
        - pause: {}
      # Safety windows
      scaleDownDelaySeconds: 600   # the previous version stays alive 10 min after promoting
      abortScaleDownDelaySeconds: 30
      maxSurge: "25%"
      maxUnavailable: 0

apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: bookings-api-analysis
  namespace: rutas-norte-pro
spec:
  args:
    - name: canary-service
  metrics:

    # --- 1. 5xx error rate ---
    - name: error-rate
      interval: 1m
      # Tolerates 2 isolated bad readings; 3 in a row abort.
      failureLimit: 2
      consecutiveErrorLimit: 3
      # Does not judge during the first 2 min: the pods are warming up.
      initialDelay: 2m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            sum(rate(rutasnorte_requests_total{
              service="{{args.canary-service}}", code=~"5.."
            }[2m]))
            /
            sum(rate(rutasnorte_requests_total{
              service="{{args.canary-service}}"
            }[2m]))
      # Passes if the result is < 0.5 %. NaN (no traffic) is accepted too:
      # with no requests there is no evidence of failure.
      successCondition: result[0] < 0.005 || isNaN(result[0])

    # --- 2. 95th percentile of latency ---
    - name: latency-p95
      interval: 1m
      failureLimit: 2
      initialDelay: 2m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            histogram_quantile(0.95,
              sum by (le) (rate(rutasnorte_request_duration_seconds_bucket{
                service="{{args.canary-service}}"
              }[2m]))
            )
      successCondition: result[0] < 0.35 || isNaN(result[0])   # 350 ms

    # --- 3. Relative comparison against the stable version ---
    # An absolute threshold can miss a regression if the system was
    # already slow. This metric requires the canary to be no more than
    # 20 % worse than the stable version.
    - name: relative-latency
      interval: 2m
      failureLimit: 1
      initialDelay: 5m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            (
              histogram_quantile(0.95, sum by (le) (rate(
                rutasnorte_request_duration_seconds_bucket{service="bookings-api-canary"}[3m])))
              /
              histogram_quantile(0.95, sum by (le) (rate(
                rutasnorte_request_duration_seconds_bucket{service="bookings-api-stable"}[3m])))
            )
      successCondition: result[0] < 1.2 || isNaN(result[0])

    # --- 4. Business metric: the one that really matters ---
    # A version can have 0 errors and perfect latency, and have broken
    # the "confirm booking" button. This catches that.
    - name: conversion-rate
      interval: 5m
      failureLimit: 1
      initialDelay: 10m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            sum(rate(rutasnorte_bookings_confirmed_total{
              service="bookings-api-canary"}[5m]))
            /
            sum(rate(rutasnorte_bookings_started_total{
              service="bookings-api-canary"}[5m]))
      successCondition: result[0] > 0.55 || isNaN(result[0])

kubectl argo rollouts get rollout bookings-api -n rutas-norte-pro --watch

Name:            bookings-api
Namespace:       rutas-norte-pro
Status:          ✖ Degraded
Message:         RolloutAborted: metric "error-rate" assessed Failed
Strategy:        Canary
  Step:          2/9
  SetWeight:     0
  ActualWeight:  0
Images:          bookings-api@sha256:3f9c1b7e (stable)
                 bookings-api@sha256:9a8b7c6d (canary)
Replicas:
  Desired:       8
  Current:       8
  Updated:       0
  Ready:         8
  Available:     8

NAME                                     KIND         STATUS        AGE   INFO
⟳ bookings-api                           Rollout      ✖ Degraded    41d
├──# revision:18
│  └──⧉ bookings-api-6d9f7b4c8            ReplicaSet   • ScaledDown  14m   canary
│     └──⊞ bookings-api-analysis-18       AnalysisRun  ✖ Failed      12m
│        ├──📊 error-rate                 Measurement  ✖ Failed            0.021
│        └──📊 latency-p95                Measurement  ✔ Successful        0.198
└──# revision:17
   └──⧉ bookings-api-7d4b8c9f5            ReplicaSet   ✔ Healthy     14d   stable

kubectl argo rollouts promote bookings-api -n rutas-norte-pro        # advance one step
kubectl argo rollouts promote bookings-api -n rutas-norte-pro --full # jump to 100 %
kubectl argo rollouts abort bookings-api -n rutas-norte-pro          # abort now
kubectl argo rollouts undo bookings-api -n rutas-norte-pro --to-revision=17

kubectl argo rollouts dashboard -n rutas-norte-pro

# In the Argo CD Application
spec:
  ignoreDifferences:
    - group: argoproj.io
      kind: Rollout
      jsonPointers:
        - /spec/replicas          # governed by the HPA
  syncPolicy:
    automated:
      selfHeal: true
      # The Rollouts controller modifies the Services during the
      # progression; without this, selfHeal would fight against it.
    syncOptions:
      - RespectIgnoreDifferences=true

spec:
  scaleTargetRef:
    apiVersion: argoproj.io/v1alpha1
    kind: Rollout
    name: bookings-api

apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: bookings-api
  namespace: rutas-norte-pro
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment          # ← the original Deployment, untouched
    name: bookings-api
  autoscalerRef:
    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    name: bookings-api
  provider: nginx
  service:
    port: 80
    targetPort: 8080
  analysis:
    interval: 1m
    threshold: 5              # failed measurements before aborting
    maxWeight: 50
    stepWeight: 10
    metrics:
      - name: request-success-rate
        thresholdRange: { min: 99.5 }
        interval: 2m
      - name: request-duration
        thresholdRange: { max: 350 }
        interval: 2m
    webhooks:
      - name: load-tests
        type: rollout
        url: http://flagger-loadtester.platform/
        metadata:
          cmd: "hey -z 2m -q 10 -c 2 http://bookings-api-canary.rutas-norte-pro/schedules"

// bookings-api: the feature ships deployed but switched off.
app.post('/bookings', async (req, res) => {
  const useNewEngine = await flags.enabled('pricing-engine-v2', {
    userId: req.user.id,
    percentage: 5,                       // progressive rollout by user
    allowList: ['rutasnorte-employees']
  });

  const price = useNewEngine
    ? await pricingEngineV2.calculate(req.body)
    : await pricingEngineV1.calculate(req.body);

  // Metric labelled by flag: lets you compare both paths
  // in Grafana without deploying anything different.
  metrics.priceCalculated.inc({ engine: useNewEngine ? 'v2' : 'v1' });
  ...
});

# AnalysisTemplate specific to this release, with tighter thresholds
# than usual because peak season is so close.
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: may-bank-holiday-analysis
  namespace: rutas-norte-pro
spec:
  metrics:
    - name: error-rate
      interval: 30s
      failureLimit: 1            # minimal tolerance: one bad reading aborts
      initialDelay: 2m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            sum(rate(rutasnorte_requests_total{service="bookings-api-canary",code=~"5.."}[2m]))
            / sum(rate(rutasnorte_requests_total{service="bookings-api-canary"}[2m]))
      successCondition: result[0] < 0.003 || isNaN(result[0])      # 0.3 %

    - name: latency-p95
      interval: 30s
      failureLimit: 1
      initialDelay: 2m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            histogram_quantile(0.95, sum by (le) (rate(
              rutasnorte_request_duration_seconds_bucket{service="bookings-api-canary"}[2m])))
      successCondition: result[0] < 0.30 || isNaN(result[0])        # 300 ms

    - name: payment-gateway-errors
      interval: 1m
      failureLimit: 1
      initialDelay: 5m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            sum(rate(rutasnorte_payments_failed_total{service="bookings-api-canary"}[5m]))
            / sum(rate(rutasnorte_payment_attempts_total{service="bookings-api-canary"}[5m]))
      successCondition: result[0] < 0.02 || isNaN(result[0])        # 2 %

    - name: conversion
      interval: 5m
      failureLimit: 1
      initialDelay: 15m
      provider:
        prometheus:
          address: http://prometheus-operated.monitoring:9090
          query: |
            sum(rate(rutasnorte_bookings_confirmed_total{service="bookings-api-canary"}[10m]))
            / sum(rate(rutasnorte_bookings_started_total{service="bookings-api-canary"}[10m]))
      successCondition: result[0] > 0.55 || isNaN(result[0])

metrics:
  - name: error-rate
    interval: 10s
    failureLimit: 0
    provider:
      prometheus:
        address: http://prometheus-operated.monitoring:9090
        query: |
          sum(rate(rutasnorte_requests_total{code=~"5.."}[30s]))
          / sum(rate(rutasnorte_requests_total[30s]))
    successCondition: result[0] < 0.001

metrics:
  - name: error-rate
    interval: 1m
    failureLimit: 2
    consecutiveErrorLimit: 3
    initialDelay: 2m
    provider:
      prometheus:
        address: http://prometheus-operated.monitoring:9090
        query: |
          sum(rate(rutasnorte_requests_total{service="bookings-api-canary",code=~"5.."}[2m]))
          / sum(rate(rutasnorte_requests_total{service="bookings-api-canary"}[2m]))
    successCondition: result[0] < 0.005 || isNaN(result[0])