Distribuzione di Whisper sul cloud: guida completa al deployment di OpenAI Whisper sulle piattaforme cloud

Introduzione

• Controllo completo su modello e infrastruttura
• Scalabilità per carichi di lavoro variabili
• Ottimizzazione dei costi tramite gestione delle risorse
• Privacy mantenendo i dati nel proprio ambiente cloud
• Personalizzazione per esigenze di dominio specifiche

---

Perché distribuire Whisper sul cloud?

Vantaggi del deployment cloud

• Auto-scaling in base alla domanda
• Gestione dei picchi di traffico senza intervento manuale
• Riduzione della capacità nei periodi di basso utilizzo per risparmiare

• Paghi solo le risorse di calcolo utilizzate
• Nessun investimento iniziale in hardware
• Ottimizza le istanze GPU per l’elaborazione batch

• Ridondanza e failover integrati
• Infrastruttura gestita che riduce i tempi di inattività
• Backup automatici e disaster recovery

• Deployment in più regioni per bassa latenza
• Integrazione CDN per contenuti più veloci
• Conformità ai requisiti regionali sui dati

• Integrazione semplice con servizi cloud nativi
• Opzioni serverless per carichi guidati dagli eventi
• Database e storage gestiti

---

Opzioni di piattaforma cloud

AWS (Amazon Web Services)

• EC2 (Elastic Compute Cloud) – istanze GPU (g4dn, p3, p4d)
• ECS/EKS – orchestrazione dei container
• Lambda – funzioni serverless (con limitazioni)
• S3 – storage dei file audio
• SQS – code per l’elaborazione batch

• Ampia scelta di istanze GPU
• Ecosistema e documentazione maturi
• Forte supporto enterprise

• Può essere complesso per i principianti
• I prezzi possono essere poco trasparenti

---

Google Cloud Platform (GCP)

• Compute Engine – istanze GPU (N1, A2)
• Cloud Run – container serverless
• GKE (Google Kubernetes Engine) – Kubernetes gestito
• Cloud Storage – storage dei file audio
• Cloud Tasks – gestione delle code di attività

• Ottimo tooling ML/AI
• Prezzi GPU competitivi
• Forte supporto a Kubernetes

• Ecosistema più piccolo di AWS
• Meno funzionalità orientate all’enterprise

---

Microsoft Azure

• Virtual Machines – istanze GPU (serie NC, ND)
• Azure Container Instances – container serverless
• AKS (Azure Kubernetes Service) – Kubernetes gestito
• Blob Storage – storage dei file audio
• Service Bus – code di messaggi

• Buona integrazione con lo stack Microsoft
• Prezzi competitivi
• Forte supporto al cloud ibrido

• Ecosistema ML/AI più piccolo
• Meno documentazione specifica su Whisper

---

Pattern architetturali di deployment

Pattern 1: Deployment containerizzato (consigliato)

Load Balancer → API Gateway → Container Service (ECS/GKE/AKS) → Whisper Containers
                                      ↓
                              Queue System (SQS/Cloud Tasks)
                                      ↓
                              Storage (S3/GCS/Blob)

• API Gateway – gestisce le richieste in ingresso
• Container Service – esegue i container Whisper
• Queue System – gestisce l’elaborazione dei job
• Storage – memorizza file audio e trascrizioni

• Facile scalabilità orizzontale
• Deployment coerente tra ambienti
• Rollback e versioning semplici

FROM python:3.10-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    ffmpeg \
    git \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Install Whisper
RUN pip install openai-whisper

# Copy application code
COPY . .

EXPOSE 8000

CMD ["python", "app.py"]

---

Pattern 2: Deployment serverless

API Gateway → Lambda/Cloud Functions → Whisper Processing
                    ↓
            Storage (S3/GCS/Blob)

• Carichi da basso a medio volume
• Elaborazione guidata dagli eventi
• Ottimizzazione dei costi con uso sporadico

• Latenza dei cold start
• Vincoli di memoria e timeout
• Limitazioni nell’accesso alle GPU

• Trascrizione attivata da webhook
• Job batch pianificati
• Bassa latenza non critica

---

Pattern 3: Deployment Kubernetes

Ingress → API Service → Whisper Deployment (Replicas)
                              ↓
                    Persistent Volume (GPU)
                              ↓
                    Job Queue (Redis/RabbitMQ)

• Sistemi di produzione ad alto volume
• Esigenze di orchestrazione complesse
• Deployment multi-regione

• Deployment – gestisce i pod Whisper
• Service – bilanciamento del carico
• HPA (Horizontal Pod Autoscaler) – auto-scaling
• GPU Node Pools – risorse GPU dedicate

---

Passo dopo passo: deployment AWS

Prerequisiti

• Account AWS con permessi adeguati
• Docker installato in locale
• AWS CLI configurata

Passo 1: Creare repository ECR

aws ecr create-repository --repository-name whisper-api

Passo 2: Build e push dell’immagine Docker

# Build image
docker build -t whisper-api .

# Tag for ECR
docker tag whisper-api:latest <account-id>.dkr.ecr.<region>.amazonaws.com/whisper-api:latest

# Push to ECR
aws ecr get-login-password --region <region> | docker login --username AWS --password-stdin <account-id>.dkr.ecr.<region>.amazonaws.com
docker push <account-id>.dkr.ecr.<region>.amazonaws.com/whisper-api:latest

Passo 3: Creare cluster ECS

aws ecs create-cluster --cluster-name whisper-cluster

Passo 4: Creare task definition

{
  "family": "whisper-api",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "2048",
  "memory": "4096",
  "containerDefinitions": [
    {
      "name": "whisper-api",
      "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/whisper-api:latest",
      "portMappings": [
        {
          "containerPort": 8000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {
          "name": "WHISPER_MODEL",
          "value": "base"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/whisper-api",
          "awslogs-region": "<region>",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

Passo 5: Creare servizio ECS

aws ecs create-service \
  --cluster whisper-cluster \
  --service-name whisper-service \
  --task-definition whisper-api \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[subnet-xxx],securityGroups=[sg-xxx],assignPublicIp=ENABLED}"

---

Passo dopo passo: deployment GCP

Passo 1: Build immagine container

gcloud builds submit --tag gcr.io/<project-id>/whisper-api

Passo 2: Deploy su Cloud Run

gcloud run deploy whisper-api \
  --image gcr.io/<project-id>/whisper-api \
  --platform managed \
  --region us-central1 \
  --memory 4Gi \
  --cpu 2 \
  --allow-unauthenticated

Passo 3: Deploy su GKE (Kubernetes)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: whisper-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: whisper-api
  template:
    metadata:
      labels:
        app: whisper-api
    spec:
      containers:
      - name: whisper-api
        image: gcr.io/<project-id>/whisper-api:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            memory: "8Gi"
            cpu: "4"

---

Strategie di ottimizzazione dei costi

1. Dimensionare correttamente le istanze

• Istanze CPU – più economiche, più lente (adatte a basso volume)
• Istanze GPU – più costose, più veloci (adatte ad alto volume)

2. Auto-scaling

• Profondità della coda
• Utilizzo CPU
• Frequenza delle richieste

{
  "minCapacity": 1,
  "maxCapacity": 10,
  "targetTrackingScalingPolicies": [
    {
      "targetValue": 70.0,
      "predefinedMetricSpecification": {
        "predefinedMetricType": "ECSServiceAverageCPUUtilization"
      }
    }
  ]
}

3. Istanze spot (AWS)

• Fino al 90% di risparmio
• Adatte a carichi non critici
• Richiede architettura tollerante ai guasti

4. Istanze riservate

• Impegni da 1 o 3 anni
• Risparmi significativi (30–60%)
• Ideali per produzione stabile

5. Serverless per carichi sporadici

• Elaborazione a basso volume guidata dagli eventi
• Job batch pianificati
• Handler webhook

---

Ottimizzazione delle prestazioni

1. Scelta della dimensione del modello

Modello	Dimensione	Velocità	Precisione	Caso d’uso
tiny	39M	Massima	Inferiore	Sviluppo, test
base	74M	Veloce	Buona	App a bassa latenza
small	244M	Media	Migliore	Produzione generale
medium	769M	Più lenta	Alta	Alta precisione
large	1550M	Minima	Massima	Precisione massima richiesta

2. Elaborazione batch

• Riduce l’overhead di avvio dei container
• Migliore utilizzo della GPU
• Costo per file inferiore

3. Cache

• File audio identici
• Contenuti consultati spesso
• Ridurre elaborazioni ridondanti

4. Pre-elaborazione audio

• Normalizzare i livelli
• Rimuovere il silenzio
• Comprimere se appropriato
• Convertire nel formato ottimale (WAV, 16 kHz)

---

Monitoraggio e logging

Metriche chiave

• Latenza di trascrizione (P50, P95, P99)
• Throughput (trascrizioni al minuto)
• Tasso di errore
• Profondità della coda

• Utilizzo CPU
• Utilizzo memoria
• Utilizzo GPU (se applicabile)
• I/O di rete

• Trascrizioni totali elaborate
• Costo per trascrizione
• Soddisfazione utente

Best practice di logging

import logging
import json

logger = logging.getLogger(__name__)

def log_transcription(audio_id, duration, model, latency):
    logger.info(json.dumps({
        "event": "transcription_complete",
        "audio_id": audio_id,
        "duration_seconds": duration,
        "model": model,
        "latency_ms": latency
    }))

• Usare logging nativo del cloud (CloudWatch, Stackdriver, Azure Monitor)
• Aggregare i log da tutte le istanze
• Configurare alert su errori e anomalie

---

Considerazioni sulla sicurezza

1. Crittografia dei dati

• In transito: HTTPS/TLS per tutte le chiamate API
• A riposo: abilitare la crittografia dello storage (S3, GCS, Blob)

2. Controllo degli accessi

• Usare ruoli e policy IAM
• Implementare autenticazione API (chiavi API, OAuth)
• Limitare l’accesso di rete (VPC, security group)

3. Gestione dei segreti

• Conservare le chiavi API nei secret manager (AWS Secrets Manager, GCP Secret Manager)
• Non incorporare mai credenziali nel codice
• Ruotare i segreti regolarmente

4. Conformità

• HIPAA per dati sanitari
• GDPR per dati UE
• SOC 2 per clienti enterprise

---

Sfide comuni e soluzioni

Sfida 1: Cold start

• Usare concorrenza provisionata (AWS Lambda)
• Mantenere i container caldi (istanze minime su Cloud Run)
• Preferire il deployment containerizzato

Sfida 2: Disponibilità GPU

• Usare più regioni
• Considerare le istanze spot
• Preriservare capacità per la produzione

Sfida 3: Sforamenti di budget

• Configurare alert di fatturazione
• Usare tag di allocazione costi
• Monitorare l’utilizzo delle risorse
• Implementare quote di utilizzo

Sfida 4: Ritardi nello scaling

• Preriscaldare le istanze nei picchi noti
• Usare scaling predittivo
• Aumentare la capacità minima

---

Riepilogo delle best practice

Infrastruttura

Applicazione

Gestione dei costi

---

Conclusione

1. Partire semplice – con un deployment containerizzato di base
2. Monitorare da vicino – prestazioni e costi fin dal primo giorno
3. Ottimizzare in modo iterativo – in base all’uso reale
4. Scalare con criterio – auto-scaling con limiti appropriati

---

Prossimi passi

• Valutare il carico – volume, requisiti di latenza e budget
• Scegliere una piattaforma – AWS, GCP o Azure in base alle esigenze
• Iniziare con un POC – deployment minimo per validare l’approccio
• Iterare e ottimizzare – affinare in base alle prestazioni reali