AI-promptengineering · Les

Strategieën voor deployment en rollback

Blue-green-promptdeployment, feature flags en rollback bij regressies.

Les 3 van 413 stappen

Strategieën voor deployment en rollback is een gratis AI-promptengineering-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.

Uitdagingen bij promptuitrol

Een nieuwe promptversie naar productie uitrollen brengt echte risico's met zich mee — een wijziging die de gemiddelde kwaliteit verbetert, kan randgevallen verslechteren, pieken in latentie veroorzaken of gebruikers in verwarring brengen. Gecontroleerde uitrolstrategieën beperken dit risico door het impactbereik te beperken en snel terugdraaien mogelijk te maken.

Blauw-groene promptuitrol

Bij een blauw-groene uitrol worden twee omgevingen bijgehouden: blauw (de huidige productieomgeving) en groen (de nieuwe versie). Na validatie wordt het verkeer atomair van blauw naar groen omgeschakeld. Als groen faalt, wordt de omschakeling direct teruggedraaid.

Omschakelen zonder uitvaltijd
Beide versies blijven tegelijkertijd gereed
Terugdraaien is één configuratiewijziging, geen nieuwe uitrol

# prompt_router.py — blue/green traffic control
class PromptRouter:
    def __init__(self):
        self.slots = {
            'blue': None,   # {'prompt_id': ..., 'version': ...}
            'green': None,
        }
        self.active_slot = 'blue'

    def load_slot(self, slot, prompt_id, version, template):
        self.slots[slot] = {
            'prompt_id': prompt_id,
            'version': version,
            'template': template
        }
        print(f'Loaded {prompt_id}@{version} into {slot} slot')

    def switch_to(self, slot):
        if not self.slots[slot]:
            raise ValueError(f'Slot {slot} is empty')
        self.active_slot = slot
        info = self.slots[slot]
        print(f'Traffic now routed to {slot}: {info["prompt_id"]}@{info["version"]}')

    def get_active_template(self):
        return self.slots[self.active_slot]['template']

Verkeer splitsen voor een geleidelijke uitrol

In plaats van 100% van het verkeer in één keer om te schakelen, vergroot je geleidelijk het aandeel dat naar de nieuwe versie wordt gestuurd. Een gebruikelijke opbouw is: 1% → 5% → 10% → 25% → 50% → 100%, met kwaliteitsbewaking bij elke stap.

import random

class TrafficSplitter:
    def __init__(self):
        # version_weights: {version_id: percentage}
        self.version_weights = {
            'v1.1.0': 90,
            'v1.2.0': 10
        }

    def select_version(self):
        versions = list(self.version_weights.keys())
        weights = list(self.version_weights.values())
        return random.choices(versions, weights=weights, k=1)[0]

    def update_split(self, new_weights):
        assert sum(new_weights.values()) == 100, 'Weights must sum to 100'
        self.version_weights = new_weights
        print(f'Traffic split updated: {new_weights}')

# Usage
splitter = TrafficSplitter()
for _ in range(5):
    print(splitter.select_version())

# Ramp to 25%
splitter.update_split({'v1.1.0': 75, 'v1.2.0': 25})

Functievlaggen voor promptuitrol

Met functievlaggen kun je een nieuwe promptversie inschakelen voor specifieke gebruikers of segmenten (bètagebruikers, interne medewerkers) voordat je alles uitrolt. Zo combineer je de veiligheid van een geleidelijke uitrol met gericht toetsen aan realistische gebruikssituaties.

# Feature flag-based prompt selection
BETA_USER_IDS = {'user_123', 'user_456', 'user_789'}

def select_prompt_version(user_id, prompt_id, registry):
    # Check if user is in beta cohort
    if user_id in BETA_USER_IDS:
        # Try to get a beta version tagged for this prompt
        beta = registry.get_version_by_tag(prompt_id, tag='beta')
        if beta:
            return beta
    # Default: serve active (stable) version
    return registry.get_active(prompt_id)

# Example: LaunchDarkly-style flag check
def select_prompt_ld(user_id, ld_client, registry):
    use_new = ld_client.variation(
        'use-summarize-v2', {'key': user_id}, default=False
    )
    version = 'v2.0.0' if use_new else 'v1.1.0'
    return registry.get_version(prompt_id='summarize-article', version=version)

De kwaliteit van een nieuwe versie bewaken

Bewaar deze signalen realtime nadat je verkeer naar een nieuwe versie hebt geleid:

Foutpercentage: API-fouten, onjuist gevormde uitvoer, parseerfouten
Latentie: P95-reactietijd (nieuwe prompts kunnen langer en trager zijn)
Kwaliteitsscore: automatische evaluatiescore van een LLM-beoordelaar of metriek
Gebruikerssignalen: percentage negatieve beoordelingen, percentage herhaalde pogingen, sessie-uitval

from collections import defaultdict
import time

class VersionMonitor:
    def __init__(self):
        self.metrics = defaultdict(lambda: {
            'calls': 0, 'errors': 0,
            'latency_sum': 0, 'quality_sum': 0
        })

    def record(self, version, latency_ms, quality_score, error=False):
        m = self.metrics[version]
        m['calls'] += 1
        m['latency_sum'] += latency_ms
        m['quality_sum'] += quality_score
        if error:
            m['errors'] += 1

    def report(self, version):
        m = self.metrics[version]
        n = m['calls'] or 1
        return {
            'version': version,
            'calls': m['calls'],
            'error_rate': round(m['errors'] / n, 3),
            'avg_latency_ms': round(m['latency_sum'] / n),
            'avg_quality': round(m['quality_sum'] / n, 2)
        }

Automatisch terugdraaien bij kwaliteitsregressie

Handmatig terugdraaien is te traag voor incidenten in productie. Definieer voorwaarden voor terugdraaien: drempelwaarden waarbij je automatisch teruggaat naar de vorige versie zodra ze worden overschreden.

ROLLBACK_THRESHOLDS = {
    'error_rate': 0.05,      # > 5% errors trigger rollback
    'avg_latency_ms': 10000, # > 10s avg latency triggers rollback
    'avg_quality': 3.5       # < 3.5 quality score triggers rollback
}

def check_and_rollback(monitor, registry, version, previous_version):
    report = monitor.report(version)
    triggers = []

    if report['error_rate'] > ROLLBACK_THRESHOLDS['error_rate']:
        triggers.append(f'error_rate={report["error_rate"]}')
    if report['avg_latency_ms'] > ROLLBACK_THRESHOLDS['avg_latency_ms']:
        triggers.append(f'latency={report["avg_latency_ms"]}ms')
    if report['avg_quality'] < ROLLBACK_THRESHOLDS['avg_quality']:
        triggers.append(f'quality={report["avg_quality"]}')

    if triggers:
        print(f'ROLLBACK TRIGGERED: {triggers}')
        registry.activate_version('summarize-article', previous_version)
        alert_oncall(f'Prompt auto-rolled back to {previous_version}: {triggers}')
        return True
    return False

Patroon voor kanarie-uitrol

Een kanarie is een zeer klein deel van het verkeer (1-5%) dat als eerste de nieuwe promptversie ontvangt. Als de kanarie na een observatieperiode gezond blijft, wordt het verkeer geleidelijk verder omgeleid. Zo niet, dan zijn alleen de kanariegebruikers getroffen.

import time

def canary_deploy(registry, splitter, monitor, new_version, prev_version,
                  soak_minutes=30, stages=[1, 5, 25, 50, 100]):
    for pct in stages:
        splitter.update_split({
            prev_version: 100 - pct,
            new_version: pct
        })
        print(f'Stage: {pct}% canary. Soaking for {soak_minutes} min...')
        time.sleep(soak_minutes * 60)  # wait soak period

        should_rollback = check_and_rollback(
            monitor, registry, new_version, prev_version
        )
        if should_rollback:
            splitter.update_split({prev_version: 100})
            print('Canary aborted. Fully reverted to', prev_version)
            return False
        print(f'Stage {pct}% passed quality check.')

    print(f'Canary complete. {new_version} now at 100%.')
    return True

Orchestratie van de uitrolpijplijn

Een volledige pijplijn voor promptuitrol integreert validatie, de start van de kanarie, een bewakingslus en de uiteindelijke activering of het terugdraaien — allemaal geautomatiseerd, met handmatige goedkeuringsmomenten bij belangrijke stappen.

# deploy_prompt.py — full pipeline
import argparse

def deploy(prompt_id, new_version, prev_version, dry_run=False):
    print(f'=== Deploying {prompt_id}: {prev_version} -> {new_version} ===')

    # 1. Validate new version exists in registry
    artifact = registry.get_version(prompt_id, new_version)
    print(f'Found artifact: {artifact["version"]}')

    # 2. Run offline eval suite
    score = run_eval_suite(artifact['template'])
    if score < 0.90:
        raise RuntimeError(f'Eval score {score} below threshold 0.90')
    print(f'Eval passed: {score}')

    if dry_run:
        print('Dry run complete. Not deploying.')
        return

    # 3. Canary deploy with automatic rollback
    success = canary_deploy(
        registry, splitter, monitor,
        new_version, prev_version,
        soak_minutes=15, stages=[1, 5, 25, 100]
    )

    print('Deployment', 'SUCCEEDED' if success else 'FAILED')

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--new', required=True)
    parser.add_argument('--prev', required=True)
    parser.add_argument('--dry-run', action='store_true')
    args = parser.parse_args()
    deploy('summarize-article', args.new, args.prev, args.dry_run)

Procedure voor handmatig terugdraaien

Wanneer automatisch terugdraaien niet wordt geactiveerd, maar iemand kwaliteitsproblemen opmerkt, zorgt een handmatig draaiboek voor snel en consistent handelen.

# RUNBOOK: Manual Prompt Rollback
# Estimated time to execute: 2-3 minutes

# Step 1: Identify current and target versions
python manage.py prompt list-versions --prompt-id summarize-article
# Output:
#   v1.2.0  [ACTIVE]  2024-08-15  alice
#   v1.1.0  [stable]  2024-07-01  alice

# Step 2: Activate previous stable version
python manage.py prompt activate --prompt-id summarize-article --version v1.1.0
# Output: Activated summarize-article@v1.1.0

# Step 3: Verify traffic is serving old version
python manage.py prompt verify --prompt-id summarize-article
# Output: Active version: v1.1.0  Serving: 100%

# Step 4: Log the incident
python manage.py incident create \
  --title 'Prompt rollback: summarize-article v1.2.0 -> v1.1.0' \
  --severity P2 \
  --reason 'Quality score dropped from 4.1 to 3.2 after v1.2.0 deploy'

Uitrolconfiguratie als code

Definieer de uitrolconfiguratie in bestanden onder versiebeheer, zodat alle uitrolbeslissingen controleerbaar en reproduceerbaar zijn.

# deployments/summarize-article.yaml
prompt_id: summarize-article
current_stable: '1.1.0'
canary_config:
  stages: [1, 5, 25, 50, 100]
  soak_minutes_per_stage: 15
rollback_thresholds:
  error_rate_max: 0.05
  latency_p95_max_ms: 8000
  quality_score_min: 3.5
feature_flags:
  beta_group: [user_123, user_456]
alerts:
  pagerduty_key: 'PD_KEY_PLACEHOLDER'
  slack_channel: '#prompt-alerts'

# Load and apply with a deploy script
import yaml

with open('deployments/summarize-article.yaml') as f:
    config = yaml.safe_load(f)

print('Deploying with config:', config['canary_config'])

Draaiboeken voor bereikbaarheidsdiensten en evaluaties na incidenten

Schrijf na elke terugdraaiing of elk incident een evaluatie achteraf waarin je vastlegt: wat er is gebeurd, de hoofdoorzaak, de tijdlijn en de actiepunten. Draaiboeken moeten naar de evaluatie achteraf verwijzen en worden bijgewerkt met geleerde lessen.

# Post-mortem template (stored in docs/post-mortems/)

## Incident: summarize-article v1.2.0 quality regression
## Date: 2024-08-15
## Severity: P2
## Duration: 47 minutes (09:15 - 10:02 UTC)

### What happened
Deployed v1.2.0 of summarize-article. At 5% canary, quality score dropped
from 4.1 to 3.0 for articles over 2000 words.

### Root cause
New prompt template removed the explicit length constraint instruction.
Long articles caused the model to generate overly verbose summaries.

### Timeline
09:15  v1.2.0 deployed to 5% canary
09:28  Quality monitor detected avg_quality < 3.5
09:29  Auto-rollback triggered to v1.1.0
09:32  Incident acknowledged by on-call
10:02  Post-mortem drafted

### Action items
- [ ] Add length regression test to eval suite
- [ ] Update canary monitoring to separate metrics by article length
- [ ] Add changelog requirement: 'length behavior' field

Korte controle

Wat gebeurt er bij een blauw-groene promptimplementatie wanneer de groene omgeving de kwaliteitscontroles niet doorstaat?

Beantwoord dit in de interactieve les

Samenvatting van uitrolstrategieën

De uitrol van prompts naar productie vereist gestructureerde strategieën om risico's te beheersen:

Blauw-groen: twee actieve omgevingen met een directe, atomische omschakeling
Canary: verkeersopbouw van 1% → 5% → 25% → 100%, met kwaliteitscontroles bij elke stap
Functievlaggen: richt je eerst op bètagebruikers voordat je de uitrol verbreedt
Automatische terugdraaiing: terugdraaien op basis van drempelwaarden (foutenpercentage, latentie, kwaliteit)
Draaiboeken: gedocumenteerde handmatige procedures voor terugdraaien voor dienstdoende technici
Evaluaties achteraf: voortdurende verbetering na elk incident

Gratis beginnen

Leer AI-promptengineering met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 53
Lessen: 199

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Strategieën voor deployment en rollback” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Strategieën voor deployment en rollback”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.

Wat leer ik in “Strategieën voor deployment en rollback”?

Blue-green-promptdeployment, feature flags en rollback bij regressies. Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met AI-promptengineering te beginnen?

Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Strategieën voor deployment en rollback”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?

Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar AI-promptengineering