Questions d'entretien pour un Ingénieur Fiabilité Site Junior : Guide Complet

# Exemple de calcul SLI/SLO
def calculate_error_budget(total_requests, failed_requests, slo_target=0.999):
    """
    Calculer la consommation du budget d'erreur
    
    SLO : taux de réussite de 99,9 %
    Budget d'erreur : 0,1 % d'échecs autorisés
    """
    success_rate = (total_requests - failed_requests) / total_requests
    error_rate = failed_requests / total_requests
    
    # Budget d'erreur : combien de ces 0,1 % autorisés avons-nous utilisé
    allowed_errors = total_requests * (1 - slo_target)
    budget_consumed = (failed_requests / allowed_errors) * 100
    
    return {
        'success_rate': success_rate,
        'error_rate': error_rate,
        'slo_target': slo_target,
        'slo_met': success_rate >= slo_target,
        'error_budget_consumed': budget_consumed,
        'remaining_budget': max(0, 100 - budget_consumed)
    }

# Exemple
result = calculate_error_budget(
    total_requests=1000000,
    failed_requests=500,  # 0.05% taux d'erreur
    slo_target=0.999
)

print(f"Taux de réussite : {result['success_rate']:.4%}")
print(f"SLO atteint : {result['slo_met']}")
print(f"Budget d'erreur consommé : {result['error_budget_consumed']:.1f}%")

# Exemple : Automatiser le redémarrage du service
#!/bin/bash
# auto-restart-service.sh

SERVICE_NAME="myapp"
MAX_RETRIES=3
RETRY_DELAY=5

check_service() {
    systemctl is-active --quiet $SERVICE_NAME
    return $?
}

restart_service() {
    echo "$(date): Redémarrage de $SERVICE_NAME"
    systemctl restart $SERVICE_NAME
    
    # Attendre que le service se stabilise
    sleep $RETRY_DELAY
    
    if check_service; then
        echo "$(date): $SERVICE_NAME redémarré avec succès"
        # Envoyer une notification
        curl -X POST https://alerts.company.com/webhook \
          -d "{\"message\": \"$SERVICE_NAME auto-redémarré\"}"
        return 0
    else
        return 1
    fi
}

# Logique principale
if ! check_service; then
    echo "$(date): $SERVICE_NAME est hors service"
    
    for i in $(seq 1 $MAX_RETRIES); do
        echo "Tentative $i sur $MAX_RETRIES"
        if restart_service; then
            exit 0
        fi
        sleep $RETRY_DELAY
    done
    
    # Toutes les tentatives ont échoué - escalader
    echo "$(date): Impossible de redémarrer $SERVICE_NAME après $MAX_RETRIES tentatives"
    curl -X POST https://pagerduty.com/api/incidents \
      -d "{\"service\": \"$SERVICE_NAME\", \"severity\": \"critical\"}"
    exit 1
fi

# Configuration de scrape Prometheus
scrape_configs:
  - job_name: 'api-server'
    static_configs:
      - targets: ['localhost:8080']
    metrics_path: '/metrics'
    scrape_interval: 15s

# Mauvais : Alerte sur CPU élevé
- alert: HighCPU
  expr: cpu_usage > 80
  
# Bon : Alerte sur l'impact utilisateur
- alert: HighLatency
  expr: http_request_duration_seconds{quantile="0.95"} > 1
  for: 5m
  annotations:
    summary: "La latence de l'API est élevée"
    description: "La latence au 95e percentile est de {{ $value }}s"

- alert: DatabaseConnectionPoolExhausted
  expr: db_connection_pool_active / db_connection_pool_max > 0.9
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "Le pool de connexions à la base de données est presque épuisé"
    runbook: "https://wiki.company.com/runbooks/db-connections"

# Digne d'un appel (réveille quelqu'un)
- alert: ServiceDown
  expr: up{job="api"} == 0
  for: 1m
  labels:
    severity: critical
    
# Digne d'un ticket (à traiter pendant les heures de bureau)
- alert: DiskSpaceWarning
  expr: disk_free_percent < 20
  for: 30m
  labels:
    severity: warning

# Liste de contrôle pour une évaluation rapide
- Quel est l'impact sur l'utilisateur ?
- Combien d'utilisateurs sont affectés ?
- Quels services sont impactés ?
- La situation empire-t-elle ?

# Stratégies d'atténuation courantes
- Annuler un déploiement récent
- Mettre à l'échelle les ressources
- Désactiver une fonctionnalité problématique
- Basculer vers un système de sauvegarde
- Limiter le trafic

# Modèle de Post-mortem d'Incident

## Résumé
Brève description de ce qui s'est passé

## Impact
- Durée : 2024-11-25 10:00 - 10:45 UTC (45 minutes)
- Utilisateurs affectés : ~10 000 (5 % du total)
- Services impactés : API, Frontend Web

## Cause première
Pool de connexions à la base de données épuisé en raison de requêtes lentes

## Chronologie
- 10:00 : Alerte déclenchée pour une latence API élevée
- 10:05 : Ingénieur de garde accusé réception
- 10:10 : Identification de la base de données comme goulot d'étranglement
- 10:15 : Augmentation de la taille du pool de connexions (atténuation)
- 10:30 : Identification et suppression des requêtes lentes
- 10:45 : Service entièrement rétabli

## Résolution
- Immédiate : Augmentation du pool de connexions de 100 à 200
- Court terme : Ajout d'un délai d'attente pour les requêtes (30s)
- Long terme : Optimisation des requêtes lentes, ajout d'une surveillance des requêtes

## Actions à entreprendre
- [ ] Ajouter une alerte pour les requêtes lentes (Responsable : Alice, Échéance : 2024-12-01)
- [ ] Implémenter un délai d'attente pour les requêtes dans l'application (Responsable : Bob, Échéance : 2024-12-05)
- [ ] Examiner et optimiser les 10 requêtes les plus lentes (Responsable : Charlie, Échéance : 2024-12-10)

## Leçons apprises
- La surveillance du pool de connexions était insuffisante
- La dégradation des performances des requêtes est passée inaperçue

# 1. Vérifier le problème
curl -w "@curl-format.txt" -o /dev/null -s https://api.example.com/health

# curl-format.txt :
#     time_namelookup:  %{time_namelookup}s\n
#        time_connect:  %{time_connect}s\n
#     time_appconnect:  %{time_appconnect}s\n
#    time_pretransfer:  %{time_pretransfer}s\n
#       time_redirect:  %{time_redirect}s\n
#  time_starttransfer:  %{time_starttransfer}s\n
#                     ----------\n
#          time_total:  %{time_total}s\n

# 2. Vérifier les métriques de l'application
# - Taux de requêtes (pic soudain ?)
# - Taux d'erreur (erreurs causant des tentatives de réexécution ?)
# - Utilisation des ressources (CPU, mémoire)

# 3. Vérifier les dépendances
# - Temps de requête de la base de données
# - Appels d'API externes
# - Taux de succès du cache

# 4. Vérifier l'infrastructure
top  # Utilisation du CPU
free -h  # Mémoire
iostat  # E/S disque
netstat -s  # Statistiques réseau

# 5. Vérifier les logs pour les erreurs
tail -f /var/log/app/error.log | grep -i "timeout\|slow\|error"

# 6. Profiler l'application
# Exemple Python
import cProfile
cProfile.run('my_function()')

# 7. Vérifier la base de données
# Log des requêtes lentes
SELECT * FROM mysql.slow_log ORDER BY query_time DESC LIMIT 10;

# Requêtes actives
SELECT pid, query, state, query_start 
FROM pg_stat_activity 
WHERE state = 'active';

#!/usr/bin/env python3
"""
Vérificateur de l'état du service avec capacité de redémarrage automatique
"""
import requests
import subprocess
import time
import sys
from datetime import datetime

class ServiceMonitor:
    def __init__(self, service_name, health_url, max_retries=3):
        self.service_name = service_name
        self.health_url = health_url
        self.max_retries = max_retries
    
    def check_health(self):
        """Vérifier si le service est sain"""
        try:
            response = requests.get(
                self.health_url,
                timeout=5
            )
            return response.status_code == 200
        except requests.exceptions.RequestException as e:
            print(f"{datetime.now()}: Le contrôle de l'état a échoué : {e}")
            return False
    
    def restart_service(self):
        """Redémarrer le service en utilisant systemctl"""
        try:
            print(f"{datetime.now()}: Redémarrage de {self.service_name}")
            subprocess.run(
                ['systemctl', 'restart', self.service_name],
                check=True,
                capture_output=True
            )
            time.sleep(10)  # Attendre que le service démarre
            return True
        except subprocess.CalledProcessError as e:
            print(f"{datetime.now()}: Le redémarrage a échoué : {e.stderr}")
            return False
    
    def send_alert(self, message, severity='warning'):
        """Envoyer une alerte au système de surveillance"""
        try:
            requests.post(
                'https://alerts.company.com/webhook',
                json={
                    'service': self.service_name,
                    'message': message,
                    'severity': severity,
                    'timestamp': datetime.now().isoformat()
                },
                timeout=5
            )
        except Exception as e:
            print(f"Échec de l'envoi de l'alerte : {e}")
    
    def monitor(self):
        """Boucle de surveillance principale"""
        if self.check_health():
            print(f"{datetime.now()}: {self.service_name} est sain")
            return 0
        
        print(f"{datetime.now()}: {self.service_name} n'est pas sain")
        self.send_alert(f"{self.service_name} est hors service", severity='warning')
        
        # Tentative de redémarrage
        for attempt in range(1, self.max_retries + 1):
            print(f"Tentative de redémarrage {attempt}/{self.max_retries}")
            
            if self.restart_service() and self.check_health():
                print(f"{datetime.now()}: Service rétabli")
                self.send_alert(
                    f"{self.service_name} s'est auto-rétabli après le redémarrage",
                    severity='info'
                )
                return 0
            
            time.sleep(5)
        
        # Toutes les tentatives ont échoué
        print(f"{datetime.now()}: Échec de la récupération du service")
        self.send_alert(
            f"{self.service_name} n'a pas pu être récupéré après {self.max_retries} tentatives",
            severity='critical'
        )
        return 1

if __name__ == '__main__':
    monitor = ServiceMonitor(
        service_name='myapp',
        health_url='http://localhost:8080/health'
    )
    sys.exit(monitor.monitor())

# Runbook : Latence API élevée

## Symptômes
- Latence API au 95e percentile > 1 seconde
- Plaintes des utilisateurs concernant le chargement lent des pages
- Alerte : "HighAPILatency" se déclenche

## Gravité
**Avertissement** - Dégrade l'expérience utilisateur mais le service est fonctionnel

## Étapes d'investigation

### 1. Vérifier les métriques actuelles
```bash
# Vérifier la distribution de la latence
curl -s http://prometheus:9090/api/v1/query?query='histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))'

# Vérifier le taux de requêtes
curl -s http://prometheus:9090/api/v1/query?query='rate(http_requests_total[5m])'

# Connexions à la base de données
mysql -e "SHOW PROCESSLIST;"

# Latence Redis
redis-cli --latency

# API externes
curl -w "%{time_total}\n" -o /dev/null -s https://external-api.com/health

kubectl scale deployment api --replicas=10

redis-cli CONFIG SET maxmemory-policy allkeys-lru

kubectl rollout undo deployment/api

kubectl apply -f rate-limit-config.yaml

from enum import Enum
import time

class CircuitState(Enum):
    CLOSED = "closed"  # Fonctionnement normal
    OPEN = "open"      # En panne, rejeter les requêtes
    HALF_OPEN = "half_open"  # Test de récupération

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = None
        self.state = CircuitState.CLOSED
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure_time > self.timeout:
                self.state = CircuitState.HALF_OPEN
            else:
                # Retourner un fallback au lieu d'appeler un service en panne
                return self.fallback()
        
        try:
            result = func(*args, **kwargs)
            self.on_success()
            return result
        except Exception as e:
            self.on_failure()
            return self.fallback()
    
    def on_success(self):
        self.failures = 0
        self.state = CircuitState.CLOSED
    
    def on_failure(self):
        self.failures += 1
        self.last_failure_time = time.time()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN
    
    def fallback(self):
        # Retourner des données mises en cache ou une réponse par défaut
        return {"status": "degraded", "data": []}

# Utilisation
breaker = CircuitBreaker()
result = breaker.call(external_api_call, user_id=123)

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_resilient_session():
    session = requests.Session()
    
    # Stratégie de réexécution
    retry = Retry(
        total=3,
        backoff_factor=0.3,
        status_forcelist=[500, 502, 503, 504]
    )
    
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)
    
    return session

# Utilisation avec un délai d'attente
session = create_resilient_session()
try:
    response = session.get('https://api.example.com/data', timeout=5)
except requests.exceptions.Timeout:
    # Dégradation progressive - utiliser les données mises en cache
    response = get_cached_data()

# Tirer une image
docker pull nginx:latest

# Exécuter un conteneur
docker run -d \
  --name my-nginx \
  -p 8080:80 \
  nginx:latest

# Lister les conteneurs en cours d'exécution
docker ps

# Afficher les logs
docker logs my-nginx

# Exécuter une commande dans un conteneur
docker exec -it my-nginx bash

# Arrêter un conteneur
docker stop my-nginx

# Supprimer un conteneur
docker rm my-nginx

# Image de base
FROM python:3.9-slim

# Définir le répertoire de travail
WORKDIR /app

# Copier les exigences
COPY requirements.txt .

# Installer les dépendances
RUN pip install --no-cache-dir -r requirements.txt

# Copier le code de l'application
COPY . .

# Exposer le port
EXPOSE 8000

# Contrôle de l'état
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# Exécuter l'application
CMD ["python", "app.py"]

# Construire l'image
docker build -t myapp:1.0 .

# Exécuter avec des variables d'environnement
docker run -d \
  --name myapp \
  -p 8000:8000 \
  -e DATABASE_URL=postgres://db:5432/mydb \
  -e LOG_LEVEL=info \
  myapp:1.0

# Afficher l'utilisation des ressources
docker stats myapp

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://db:5432/mydb
    depends_on:
      - db
      - redis
    restart: unless-stopped
  
  db:
    image: postgres:14
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_PASSWORD=secret
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# Démarrer tous les services
docker-compose up -d

# Afficher les logs
docker-compose logs -f web

# Mettre à l'échelle le service
docker-compose up -d --scale web=3

# Arrêter tous les services
docker-compose down

# Cloner le dépôt
git clone https://github.com/company/repo.git
cd repo

# Créer une branche de fonctionnalité
git checkout -b feature/ajouter-surveillance

# Effectuer des modifications et valider
git add .
git commit -m "Ajouter la surveillance Prometheus"

# Pousser vers le dépôt distant
git push origin feature/ajouter-surveillance

# Mettre à jour à partir de main
git checkout main
git pull origin main
git checkout feature/ajouter-surveillance
git rebase main

# Fusionner la fonctionnalité (après approbation de la PR)
git checkout main
git merge feature/ajouter-surveillance
git push origin main

# Branches de fonctionnalités de courte durée
git checkout -b