Strategie di deployment e rollback
Deployment blue-green dei prompt, feature flag e rollback in caso di regressione
Strategie di deployment e rollback è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.
Sfide nella distribuzione dei prompt
La distribuzione in produzione di una nuova versione di un prompt comporta rischi concreti: una modifica che migliora la qualità media può danneggiare i casi limite, causare picchi di latenza o confondere gli utenti. Le strategie di distribuzione controllata gestiscono questo rischio limitando il raggio d'azione e consentendo un rollback rapido.
Distribuzione blue-green dei prompt
La distribuzione blue-green mantiene due ambienti: blue (la produzione corrente) e green (la nuova versione). Dopo la validazione, il traffico viene trasferito atomicamente da blue a green. Se green presenta problemi, il trasferimento viene annullato immediatamente.
- Passaggi senza downtime
- Entrambe le versioni rimangono pronte contemporaneamente
- Il rollback consiste in una singola modifica alla configurazione, non in una nuova distribuzione
# 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']Suddivisione del traffico per un rollout graduale
Anziché trasferire tutto il traffico in una volta, aumenti gradualmente la quota inviata alla nuova versione. Una progressione comune è: 1% → 5% → 10% → 25% → 50% → 100%, monitorando la qualità a ogni passaggio.
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})Feature flag per il rollout dei prompt
I feature flag consentono di abilitare una nuova versione del prompt per utenti o segmenti specifici (utenti beta, personale interno) prima del rollout completo. Questa soluzione combina la sicurezza di un rollout graduale con test mirati su casi d'uso reali.
# 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)Monitoraggio della qualità della nuova versione
Dopo aver indirizzato il traffico verso una nuova versione, monitori questi segnali in tempo reale:
- Tasso di errore: errori API, output malformati, errori di parsing
- Latenza: tempo di risposta P95 (i nuovi prompt potrebbero essere più lunghi e lenti)
- Punteggio di qualità: punteggio di valutazione automatica prodotto da un valutatore LLM o da una metrica
- Segnali degli utenti: tasso di valutazioni negative, tasso di nuovi tentativi, abbandono della sessione
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)
}Rollback automatico in caso di regressione della qualità
Un rollback manuale è troppo lento per gli incidenti in produzione. Definisca dei trigger di rollback: soglie che, quando vengono superate, riportano automaticamente alla versione precedente.
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 FalsePattern di distribuzione canary
Un canary è una piccola quota di traffico (1-5%) a cui viene assegnata per prima la nuova versione del prompt. Se il canary rimane stabile dopo un periodo di osservazione, il traffico viene trasferito gradualmente. In caso contrario, sono interessati soltanto gli utenti del canary.
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 TrueOrchestrazione della pipeline di distribuzione
Una pipeline completa per la distribuzione dei prompt integra validazione, avvio del canary, ciclo di monitoraggio e promozione finale o rollback, il tutto automatizzato, con passaggi di approvazione umana nelle fasi chiave.
# 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)Procedura di rollback manuale
Quando il rollback automatico non si attiva ma una persona nota problemi di qualità, un runbook per il rollback manuale garantisce un'azione rapida e coerente.
# 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'Configurazione della distribuzione come codice
Definisca la configurazione della distribuzione in file sottoposti al controllo versione, così che tutte le decisioni di distribuzione siano verificabili tramite audit e riproducibili.
# 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'])Runbook di reperibilità e post-mortem
Dopo ogni rollback o incidente, rediga un post-mortem che documenti: cosa è successo, la causa principale, la cronologia e le azioni da intraprendere. I runbook devono fare riferimento al post-mortem e essere aggiornati con le lezioni apprese.
# 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' fieldVerifica rapida
In una distribuzione blue-green dei prompt, cosa succede quando lo slot green non supera i controlli di qualità?
Riepilogo delle strategie di distribuzione
La distribuzione dei prompt in produzione richiede strategie strutturate per gestire i rischi:
- Blue-green: due ambienti attivi, con passaggio atomico istantaneo
- Canary: incremento del traffico dall'1% al 5%, 25% e 100%, con controlli di qualità a ogni fase
- Feature flag: indirizzamento agli utenti beta prima dell'estensione generale
- Rollback automatico: ripristino attivato dal superamento di una soglia (tasso di errore, latenza, qualità)
- Runbook: procedure documentate per il rollback manuale a disposizione degli ingegneri on-call
- Post-mortem: miglioramento continuo dopo ogni incidente
Domande Frequenti
La lezione «Strategie di deployment e rollback» è gratuita?
Sì — il testo completo di «Strategie di deployment e rollback» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.
Cosa imparerò in «Strategie di deployment e rollback»?
Deployment blue-green dei prompt, feature flag e rollback in caso di regressione Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Prompt Engineering?
Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Strategie di deployment e rollback»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?
Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Architettura di un prompt registry
- Controllo versione dei prompt
- Strategie di deployment e rollback
- Monitoraggio delle prestazioni dei prompt in produzione