# Fichier: python_cheats/cheatsheets/auto-scaling.txt
# Cheatsheet AWS Auto Scaling - Scaling Automatique Expliqué en Détail


═══════════════════════════════════════════════════════════════════════════════
[OK] AWS AUTO SCALING - C'EST QUOI?
═══════════════════════════════════════════════════════════════════════════════

AUTO SCALING = "Ajuster automatiquement le nombre d'instances selon la charge"

ANALOGIE RESTAURANT:
- Heure creuse (10h) -> 2 serveurs suffisent
- Heure de pointe (12h) -> 10 serveurs nécessaires
- Auto Scaling = Embaucher/renvoyer serveurs automatiquement

PROBLÈME SANS AUTO SCALING:
[X] Trafic faible -> Instances inutilisées = Gaspillage d'argent
[X] Trafic élevé -> Pas assez d'instances = Site lent/crash
[X] Gestion manuelle = Réaction lente, erreurs humaines

SOLUTION AUTO SCALING:
[OK] Trafic augmente -> Ajouter instances automatiquement (scale out)
[OK] Trafic diminue -> Retirer instances automatiquement (scale in)
[OK] Payer seulement pour ce qui est nécessaire
[OK] Haute disponibilité (remplace instances défectueuses)
[OK] Réaction rapide (quelques minutes)

COMPOSANTS PRINCIPAUX:
1. LAUNCH TEMPLATE -> "Recette" pour créer instances
2. AUTO SCALING GROUP (ASG) -> Groupe gérant les instances
3. SCALING POLICIES -> Règles pour scale up/down
4. HEALTH CHECKS -> Vérifier santé instances

TERMINOLOGIE:
- SCALE OUT = Ajouter instances (horizontal scaling)
- SCALE IN = Retirer instances
- SCALE UP = Augmenter taille instance (vertical scaling) [X] Pas Auto Scaling
- DESIRED CAPACITY = Nombre d'instances souhaité actuellement
- MIN SIZE = Nombre minimum d'instances (jamais en dessous)
- MAX SIZE = Nombre maximum d'instances (jamais au-dessus)

EXEMPLE CHIFFRES:
- Min: 2 instances (toujours au moins 2 pour HA)
- Desired: 4 instances (actuellement)
- Max: 10 instances (limite pour contrôler coûts)

QUAND UTILISER AUTO SCALING?
[OK] Applications web avec trafic variable
[OK] APIs avec pics de charge
[OK] Applications batch/traitement données
[OK] Services microservices
[OK] Tout ce qui peut être horizontal (stateless)

QUAND NE PAS UTILISER?
[X] Applications stateful (sessions locales)
[X] Bases de données (utiliser RDS Auto Scaling)
[X] Trafic constant prévisible
[X] Applications legacy non-scalables


═══════════════════════════════════════════════════════════════════════════════
[OK] LAUNCH TEMPLATE - LA "RECETTE" POUR CRÉER INSTANCES
═══════════════════════════════════════════════════════════════════════════════

LAUNCH TEMPLATE = "Instructions pour créer instances EC2"

CONTIENT:
- AMI (image) à utiliser
- Type d'instance (t3.micro, t3.medium, etc.)
- Security groups
- Key pair pour SSH
- User data (script lancement)
- IAM role
- Stockage (EBS)
- Network settings

DIFFÉRENCE Launch Template vs Launch Configuration:
┌────────────────────────┬─────────────────────┬────────────────────┐
│                        │  Launch Template    │ Launch Config      │
├────────────────────────┼─────────────────────┼────────────────────┤
│ Versions               │  [OK] Oui             │  [X] Non            │
│ Modification           │  [OK] Oui             │  [X] Non (immutable)│
│ T2/T3 Unlimited        │  [OK] Oui             │  [X] Non            │
│ Multiple types         │  [OK] Oui             │  [X] Non            │
│ Spot instances         │  [OK] Meilleur        │  [ATTENTION] Limité         │
│ Recommandation AWS     │  [OK] Utiliser        │  [X] Déprécié       │
└────────────────────────┴─────────────────────┴────────────────────┘

[ATTENTION] TOUJOURS utiliser Launch Template (pas Launch Configuration)!

# CRÉER LAUNCH TEMPLATE - EXPLICATIONS DÉTAILLÉES
════════════════════════════════════════════════════════════════════════════════

# Créer launch template basique
aws ec2 create-launch-template \
  --launch-template-name web-server-template \
  --version-description "Version 1 - Initial release" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "InstanceType": "t3.micro",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-0123456789abcdef0"]
  }'

# EXPLICATION PARAMÈTRES:

# --launch-template-name
#   = Nom unique du template
#   = Minuscules, tirets OK

# --version-description
#   = Description de cette version
#   = Utile pour tracking changements

# --launch-template-data (JSON):

#   "ImageId": "ami-0c55b159cbfafe1f0"
#     = AMI à utiliser (Amazon Linux 2, Ubuntu, etc.)
#     = Trouver AMI: aws ec2 describe-images
#     = IMPORTANT: Utiliser AMI de la même région!

#   "InstanceType": "t3.micro"
#     = Taille instance
#     = t3.micro = 2 vCPU, 1 GB RAM (~$7/mois)
#     = Options: t3.small, t3.medium, m5.large, etc.

#   "KeyName": "my-key-pair"
#     = Key pair pour SSH
#     = Doit exister déjà (créer avec aws ec2 create-key-pair)

#   "SecurityGroupIds": ["sg-xxx"]
#     = Security groups pour instances
#     = Liste d'IDs (peut en avoir plusieurs)

# RÉSULTAT:
# {
#   "LaunchTemplate": {
#     "LaunchTemplateId": "lt-0123456789abcdef0",
#     "LaunchTemplateName": "web-server-template",
#     "CreateTime": "2024-01-15T10:30:00.000Z",
#     "DefaultVersionNumber": 1,
#     "LatestVersionNumber": 1
#   }
# }

# [ATTENTION] Notez LaunchTemplateId: lt-0123456789abcdef0

# CRÉER LAUNCH TEMPLATE COMPLET (PRODUCTION)
════════════════════════════════════════════════════════════════════════════════

# Préparer User Data (script bash encodé base64)
cat > user-data.sh << 'EOF'
#!/bin/bash
# Script exécuté au démarrage instance

# Update système
yum update -y

# Installer Apache
yum install -y httpd

# Créer page web
cat > /var/www/html/index.html << 'HTML'
<!DOCTYPE html>
<html>
<head><title>Auto Scaling Demo</title></head>
<body>
  <h1>Instance: $(hostname)</h1>
  <p>Servie par Auto Scaling!</p>
</body>
</html>
HTML

# Démarrer Apache
systemctl start httpd
systemctl enable httpd
EOF

# Encoder en base64
USER_DATA_BASE64=$(base64 -w 0 user-data.sh)

# Créer template complet
aws ec2 create-launch-template \
  --launch-template-name production-web-template \
  --version-description "Production v1 - Apache web server" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "InstanceType": "t3.micro",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-web123"],
    "UserData": "'$USER_DATA_BASE64'",
    "IamInstanceProfile": {
      "Name": "EC2-WebServer-Role"
    },
    "BlockDeviceMappings": [
      {
        "DeviceName": "/dev/xvda",
        "Ebs": {
          "VolumeSize": 20,
          "VolumeType": "gp3",
          "DeleteOnTermination": true,
          "Encrypted": true
        }
      }
    ],
    "Monitoring": {
      "Enabled": true
    },
    "TagSpecifications": [
      {
        "ResourceType": "instance",
        "Tags": [
          {"Key": "Name", "Value": "Web-Server-ASG"},
          {"Key": "Environment", "Value": "Production"}
        ]
      }
    ],
    "MetadataOptions": {
      "HttpTokens": "required",
      "HttpPutResponseHopLimit": 1
    }
  }'

# EXPLICATION PARAMÈTRES AVANCÉS:

# "UserData": "'$USER_DATA_BASE64'"
#   = Script bash exécuté au lancement
#   = DOIT être encodé en base64
#   = Installe logiciels, configure instance, etc.

# "IamInstanceProfile": {"Name": "EC2-WebServer-Role"}
#   = IAM role pour l'instance
#   = Donne permissions (ex: accès S3, DynamoDB)
#   = Créer avec: aws iam create-instance-profile

# "BlockDeviceMappings"
#   = Configuration disques (EBS)
#   * VolumeSize: 20 GB
#   * VolumeType: gp3 (SSD rapide, recommandé)
#   * DeleteOnTermination: true (supprimer avec instance)
#   * Encrypted: true (chiffrement au repos)

# "Monitoring": {"Enabled": true}
#   = Detailed monitoring (métriques chaque 1 min vs 5 min)
#   = Coût: $0.14/instance/mois
#   = Recommandé pour production

# "TagSpecifications"
#   = Tags appliqués aux instances créées
#   = Facilite organisation et facturation

# "MetadataOptions"
#   = Sécurité metadata service (IMDSv2)
#   * HttpTokens: required = Force IMDSv2 (plus sécurisé)
#   * HttpPutResponseHopLimit: 1 = Limite accès metadata

# CRÉER LAUNCH TEMPLATE AVEC SPOT INSTANCES
════════════════════════════════════════════════════════════════════════════════

# Spot = Instances jusqu'à 90% moins chères (mais peuvent être interrompues)

aws ec2 create-launch-template \
  --launch-template-name spot-template \
  --version-description "Spot instances template" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "InstanceType": "t3.micro",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-web123"],
    "InstanceMarketOptions": {
      "MarketType": "spot",
      "SpotOptions": {
        "MaxPrice": "0.02",
        "SpotInstanceType": "one-time",
        "InstanceInterruptionBehavior": "terminate"
      }
    }
  }'

# EXPLICATION SPOT:

# "MarketType": "spot"
#   = Utiliser instances Spot (vs on-demand)

# "MaxPrice": "0.02"
#   = Prix maximum par heure ($0.02)
#   = Si prix Spot > max -> instance terminée
#   = Laisser vide = prix on-demand (recommandé)

# "SpotInstanceType": "one-time"
#   = Requête ponctuelle (vs persistent)

# "InstanceInterruptionBehavior": "terminate"
#   = Que faire si AWS interrompt instance
#   = Options: terminate, stop, hibernate

# [ATTENTION] SPOT INSTANCES:
# Parfait pour: Batch processing, CI/CD, workloads flexibles
# Éviter pour: Bases de données, applications critiques

# CRÉER LAUNCH TEMPLATE MULTI-TYPES
════════════════════════════════════════════════════════════════════════════════

# Permet Auto Scaling d'utiliser plusieurs types d'instances

aws ec2 create-launch-template \
  --launch-template-name multi-type-template \
  --version-description "Multiple instance types" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-web123"],
    "InstanceRequirements": {
      "VCpuCount": {"Min": 2, "Max": 4},
      "MemoryMiB": {"Min": 2048, "Max": 8192}
    }
  }'

# EXPLICATION:
# InstanceRequirements = Spécifier besoins vs type exact
# Auto Scaling choisit instances disponibles matching critères
# Plus flexible et souvent moins cher

# LISTER LAUNCH TEMPLATES
════════════════════════════════════════════════════════════════════════════════

# Lister tous les templates
aws ec2 describe-launch-templates

# Format lisible
aws ec2 describe-launch-templates \
  --query 'LaunchTemplates[*].[LaunchTemplateId,LaunchTemplateName,DefaultVersionNumber,LatestVersionNumber]' \
  --output table

# RÉSULTAT EXEMPLE:
# -------------------------------------------------------------------------
# | lt-abc123  | web-server-template       | 1  | 3  |
# | lt-def456  | production-web-template   | 2  | 2  |
# -------------------------------------------------------------------------

# Obtenir template spécifique
aws ec2 describe-launch-templates \
  --launch-template-names web-server-template

# Voir détails version spécifique
aws ec2 describe-launch-template-versions \
  --launch-template-id lt-0123456789abcdef0 \
  --versions 1

# Voir dernière version
aws ec2 describe-launch-template-versions \
  --launch-template-id lt-0123456789abcdef0 \
  --versions '$Latest'

# Voir version par défaut
aws ec2 describe-launch-template-versions \
  --launch-template-id lt-0123456789abcdef0 \
  --versions '$Default'

# CRÉER NOUVELLE VERSION LAUNCH TEMPLATE
════════════════════════════════════════════════════════════════════════════════

# Créer version 2 (instance type changé)
aws ec2 create-launch-template-version \
  --launch-template-id lt-0123456789abcdef0 \
  --version-description "Version 2 - Upgraded to t3.small" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "InstanceType": "t3.small",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-web123"]
  }'

# EXPLICATION:
# Créer nouvelle version sans modifier version 1
# ASG peut continuer utiliser version 1 si configuré
# Permet rollback facile si problème

# Définir version par défaut
aws ec2 modify-launch-template \
  --launch-template-id lt-0123456789abcdef0 \
  --default-version 2

# EXPLICATION:
# Version par défaut = utilisée si ASG spécifie $Default
# Pas obligatoire de changer (peut garder $Latest)

# SUPPRIMER LAUNCH TEMPLATE
════════════════════════════════════════════════════════════════════════════════

# Supprimer version spécifique
aws ec2 delete-launch-template-versions \
  --launch-template-id lt-0123456789abcdef0 \
  --versions 1

# Supprimer template complet (toutes versions)
aws ec2 delete-launch-template \
  --launch-template-id lt-0123456789abcdef0

# [ATTENTION] ERREUR SI:
# Template utilisé par ASG actif
# SOLUTION: Supprimer/modifier ASG d'abord


═══════════════════════════════════════════════════════════════════════════════
[OK] AUTO SCALING GROUP (ASG) - LE GESTIONNAIRE
═══════════════════════════════════════════════════════════════════════════════

AUTO SCALING GROUP = "Gestionnaire qui crée/supprime instances"

RESPONSABILITÉS ASG:
1. Maintenir desired capacity (nombre souhaité)
2. Remplacer instances défectueuses
3. Distribuer instances entre AZs
4. Enregistrer instances dans Load Balancer
5. Respecter min/max size

EXEMPLE FONCTIONNEMENT:
- Min: 2, Desired: 4, Max: 10
- ASG maintient toujours 4 instances
- Si instance crash -> ASG en lance une nouvelle
- Si scaling policy déclenche -> ASG ajuste desired capacity

HEALTH CHECKS:
- EC2: Instance répond-elle? (basic)
- ELB: Load balancer considère-t-elle instance healthy? (recommandé)

# CRÉER AUTO SCALING GROUP - BASIQUE
════════════════════════════════════════════════════════════════════════════════

aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --launch-template LaunchTemplateName=web-server-template,Version='$Latest' \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 4 \
  --vpc-zone-identifier "subnet-0123456789abcdef0,subnet-abcdef0123456789"

# EXPLICATION PARAMÈTRES:

# --auto-scaling-group-name
#   = Nom unique du ASG

# --launch-template LaunchTemplateName=web-server-template,Version='$Latest'
#   = Template à utiliser
#   = Version='$Latest' = toujours dernière version
#   = Version='$Default' = version par défaut
#   = Version='1' = version spécifique

# --min-size 2
#   = Nombre MINIMUM d'instances
#   = ASG ne descendra JAMAIS en dessous
#   = Recommandé: Au moins 2 pour HA

# --max-size 10
#   = Nombre MAXIMUM d'instances
#   = ASG ne dépassera JAMAIS
#   = Protection contre facture surprise

# --desired-capacity 4
#   = Nombre d'instances souhaité MAINTENANT
#   = min-size ≤ desired-capacity ≤ max-size
#   = ASG lance/termine instances pour atteindre ce nombre

# --vpc-zone-identifier
#   = Subnets où lancer instances
#   = Format: "subnet1,subnet2,subnet3"
#   = Recommandé: 2+ subnets dans AZs différentes
#   = ASG distribue instances équitablement

# RÉSULTAT:
# ASG créé et commence à lancer 4 instances immédiatement!

# CRÉER AUTO SCALING GROUP - PRODUCTION COMPLET
════════════════════════════════════════════════════════════════════════════════

aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name production-web-asg \
  --launch-template LaunchTemplateId=lt-0123456789abcdef0,Version='$Latest' \
  --min-size 2 \
  --max-size 20 \
  --desired-capacity 4 \
  --default-cooldown 300 \
  --health-check-type ELB \
  --health-check-grace-period 300 \
  --vpc-zone-identifier "subnet-public1,subnet-public2,subnet-public3" \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-web-targets/73e2d6bc24d8a067 \
  --termination-policies "OldestInstance" \
  --tags Key=Name,Value=Web-Server-ASG,PropagateAtLaunch=true \
         Key=Environment,Value=Production,PropagateAtLaunch=true

# EXPLICATION PARAMÈTRES AVANCÉS:

# --default-cooldown 300
#   = Période refroidissement (secondes)
#   = Après scaling action, attendre 300s avant autre action
#   = Évite scaling trop agressif
#   = Défaut: 300s (5 minutes)

# --health-check-type ELB
#   = Comment vérifier santé instances
#   = EC2: Seulement si instance répond (basic)
#   = ELB: Load balancer health checks (RECOMMANDÉ)
#   = ELB + EC2: Les deux (plus strict)

# --health-check-grace-period 300
#   = Délai avant vérifier santé (secondes)
#   = Donne temps à instance de démarrer complètement
#   = 300s = 5 minutes (ajuster selon temps démarrage app)
#   = Trop court -> instances terminées prématurément

# --target-group-arns
#   = Target group du Load Balancer
#   = ASG enregistre automatiquement instances
#   = Format ARN complet
#   = Obtenir avec: aws elbv2 describe-target-groups

# --termination-policies "OldestInstance"
#   = Quelle instance terminer en premier lors scale in
#   = Options:
#     * Default: Équilibrer AZs, puis plus vieille launch config
#     * OldestInstance: Plus vieille instance
#     * NewestInstance: Plus récente instance
#     * OldestLaunchTemplate: Instance avec template le plus vieux
#     * AllocationStrategy: Pour Spot (prix)

# --tags
#   = Tags appliqués au ASG ET instances si PropagateAtLaunch=true
#   = Format: Key=Name,Value=Value,PropagateAtLaunch=true

# CRÉER ASG AVEC MULTIPLE INSTANCE TYPES (FLEXIBILITÉ)
════════════════════════════════════════════════════════════════════════════════

aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name flexible-asg \
  --mixed-instances-policy '{
    "LaunchTemplate": {
      "LaunchTemplateSpecification": {
        "LaunchTemplateId": "lt-0123456789abcdef0",
        "Version": "$Latest"
      },
      "Overrides": [
        {"InstanceType": "t3.micro", "WeightedCapacity": "1"},
        {"InstanceType": "t3.small", "WeightedCapacity": "2"},
        {"InstanceType": "t3.medium", "WeightedCapacity": "4"}
      ]
    },
    "InstancesDistribution": {
      "OnDemandPercentageAboveBaseCapacity": 50,
      "SpotInstancePools": 2
    }
  }' \
  --min-size 4 \
  --max-size 20 \
  --desired-capacity 8 \
  --vpc-zone-identifier "subnet-1,subnet-2,subnet-3"

# EXPLICATION MIXED INSTANCES POLICY:

# "Overrides"
#   = Liste types d'instances à utiliser
#   = ASG choisit selon disponibilité et prix

# "WeightedCapacity"
#   = "Poids" de chaque type
#   = t3.micro = 1 unit, t3.small = 2 units, t3.medium = 4 units
#   = Si desired=8: Peut être 8×t3.micro OU 4×t3.small OU 2×t3.medium

# "OnDemandPercentageAboveBaseCapacity": 50
#   = 50% on-demand, 50% spot
#   = Économie avec Spot tout en gardant stabilité

# "SpotInstancePools": 2
#   = Utiliser 2 Spot pools différents
#   = Répartir risque interruption

# LISTER AUTO SCALING GROUPS
════════════════════════════════════════════════════════════════════════════════

# Lister tous les ASGs
aws autoscaling describe-auto-scaling-groups

# Format lisible
aws autoscaling describe-auto-scaling-groups \
  --query 'AutoScalingGroups[*].[AutoScalingGroupName,MinSize,MaxSize,DesiredCapacity,length(Instances)]' \
  --output table

# RÉSULTAT EXEMPLE:
# -------------------------------------------------------------------------
# | my-web-asg         | 2  | 10 | 4  | 4  |
# | production-web-asg | 2  | 20 | 8  | 8  |
# -------------------------------------------------------------------------
# Colonnes: Name, Min, Max, Desired, Current instances

# Obtenir ASG spécifique
aws autoscaling describe-auto-scaling-groups \
  --auto-scaling-group-names my-web-asg

# Voir instances dans ASG
aws autoscaling describe-auto-scaling-groups \
  --auto-scaling-group-names my-web-asg \
  --query 'AutoScalingGroups[0].Instances[*].[InstanceId,LifecycleState,HealthStatus,AvailabilityZone]' \
  --output table

# RÉSULTAT EXEMPLE:
# -------------------------------------------------------------------------
# | i-abc123  | InService  | Healthy   | us-east-1a |
# | i-def456  | InService  | Healthy   | us-east-1b |
# | i-ghi789  | InService  | Healthy   | us-east-1a |
# | i-jkl012  | Pending    | Unknown   | us-east-1b |
# -------------------------------------------------------------------------

# LifecycleState:
# - Pending: En cours de lancement
# - InService: Active et reçoit trafic
# - Terminating: En cours de terminaison
# - Terminated: Terminée

# Voir activités récentes (scaling events)
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --max-records 10

# MODIFIER AUTO SCALING GROUP
════════════════════════════════════════════════════════════════════════════════

# Changer capacités (min, max, desired)
aws autoscaling update-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --min-size 3 \
  --max-size 15 \
  --desired-capacity 6

# EXPLICATION:
# Changement immédiat
# Si desired-capacity augmente -> ASG lance nouvelles instances
# Si desired-capacity diminue -> ASG termine instances

# Changer health check
aws autoscaling update-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --health-check-type ELB \
  --health-check-grace-period 600

# Changer launch template
aws autoscaling update-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --launch-template LaunchTemplateId=lt-new123,Version='$Latest'

# [ATTENTION] IMPORTANT:
# Changement launch template n'affecte PAS instances existantes!
# Seulement nouvelles instances utilisent nouveau template
# Pour mettre à jour instances existantes:
#   1. Terminer anciennes instances manuellement
#   2. Utiliser instance refresh (voir section dédiée)

# Activer métriques détaillées
aws autoscaling enable-metrics-collection \
  --auto-scaling-group-name my-web-asg \
  --granularity "1Minute" \
  --metrics GroupMinSize GroupMaxSize GroupDesiredCapacity GroupInServiceInstances

# EXPLICATION:
# Envoie métriques CloudWatch toutes les 1 minute
# Utile pour monitoring et alarmes

# DÉFINIR CAPACITÉ MANUELLE (BYPASS SCALING)
════════════════════════════════════════════════════════════════════════════════

# Forcer nombre d'instances spécifique
aws autoscaling set-desired-capacity \
  --auto-scaling-group-name my-web-asg \
  --desired-capacity 10

# EXPLICATION:
# Ignore scaling policies temporairement
# ASG lance/termine instances pour atteindre 10
# Scaling policies peuvent changer ça après

# Forcer desired capacity (ignorer cooldown)
aws autoscaling set-desired-capacity \
  --auto-scaling-group-name my-web-asg \
  --desired-capacity 10 \
  --honor-cooldown

# EXPLICATION:
# --honor-cooldown = Respecter cooldown period
# Sans = Changer immédiatement (ignorer cooldown)

# SUSPEND/RESUME PROCESSUS ASG
════════════════════════════════════════════════════════════════════════════════

# Suspendre ALL processus (ex: pendant maintenance)
aws autoscaling suspend-processes \
  --auto-scaling-group-name my-web-asg

# EXPLICATION:
# ASG arrête toutes actions automatiques:
# - Pas de nouveau lancement
# - Pas de terminaison
# - Pas de health checks
# Instances existantes continuent de tourner

# Suspendre processus spécifiques
aws autoscaling suspend-processes \
  --auto-scaling-group-name my-web-asg \
  --scaling-processes Launch Terminate HealthCheck

# PROCESSUS DISPONIBLES:
# - Launch: Lancer nouvelles instances
# - Terminate: Terminer instances
# - HealthCheck: Vérifier santé instances
# - ReplaceUnhealthy: Remplacer instances malades
# - AZRebalance: Équilibrer entre AZs
# - AlarmNotification: Réagir aux alarmes CloudWatch
# - ScheduledActions: Actions planifiées
# - AddToLoadBalancer: Enregistrer dans LB

# Reprendre processus
aws autoscaling resume-processes \
  --auto-scaling-group-name my-web-asg

# Reprendre processus spécifiques
aws autoscaling resume-processes \
  --auto-scaling-group-name my-web-asg \
  --scaling-processes Launch Terminate

# DÉTACHER INSTANCES DU ASG
════════════════════════════════════════════════════════════════════════════════

# Détacher instance (garder instance en cours)
aws autoscaling detach-instances \
  --instance-ids i-0123456789abcdef0 \
  --auto-scaling-group-name my-web-asg \
  --no-should-decrement-desired-capacity

# EXPLICATION:
# Instance retirée du ASG mais continue de tourner
# --no-should-decrement-desired-capacity
#   = ASG lance nouvelle instance pour remplacer
# --should-decrement-desired-capacity
#   = Desired capacity diminue (pas de remplacement)

# USE CASE:
# Debugging instance problématique sans la terminer
# Migrer instance hors ASG

# ATTACHER INSTANCE EXISTANTE AU ASG
════════════════════════════════════════════════════════════════════════════════

# Attacher instance EC2 existante
aws autoscaling attach-instances \
  --instance-ids i-0123456789abcdef0 \
  --auto-scaling-group-name my-web-asg

# EXPLICATION:
# Instance doit être dans état "running"
# Instance doit être dans même VPC/subnets que ASG
# Desired capacity augmente automatiquement

# TERMINER INSTANCE DANS ASG
════════════════════════════════════════════════════════════════════════════════

# Terminer instance spécifique
aws autoscaling terminate-instance-in-auto-scaling-group \
  --instance-id i-0123456789abcdef0 \
  --should-decrement-desired-capacity

# EXPLICATION:
# --should-decrement-desired-capacity
#   = Diminuer desired capacity (pas de remplacement)
#   = Use case: Scale in manuellement

# --no-should-decrement-desired-capacity
#   = Garder desired capacity (lancer nouvelle instance)
#   = Use case: Remplacer instance problématique

# METTRE INSTANCE EN STANDBY
════════════════════════════════════════════════════════════════════════════════

# Mettre instance en standby (temporaire)
aws autoscaling enter-standby \
  --instance-ids i-0123456789abcdef0 \
  --auto-scaling-group-name my-web-asg \
  --should-decrement-desired-capacity

# EXPLICATION:
# Instance reste en cours mais:
# - Retirée du Load Balancer (pas de trafic)
# - Pas de health checks
# - Compte pas dans desired capacity
# Parfait pour: Updates, debugging, maintenance

# Sortir du standby
aws autoscaling exit-standby \
  --instance-ids i-0123456789abcdef0 \
  --auto-scaling-group-name my-web-asg

# EXPLICATION:
# Instance réintégrée:
# - Enregistrée dans Load Balancer
# - Health checks reprennent
# - Compte dans desired capacity

# INSTANCE REFRESH - METTRE À JOUR INSTANCES PROGRESSIVEMENT
════════════════════════════════════════════════════════════════════════════════

# Remplacer toutes instances avec nouveau launch template
aws autoscaling start-instance-refresh \
  --auto-scaling-group-name my-web-asg \
  --preferences '{
    "MinHealthyPercentage": 90,
    "InstanceWarmup": 300
  }'

# EXPLICATION:
# Remplace instances progressivement (rolling update)
# Pas d'interruption service

# "MinHealthyPercentage": 90
#   = Garder au moins 90% instances healthy pendant refresh
#   = Si 10 instances: Remplace max 1 à la fois

# "InstanceWarmup": 300
#   = Attendre 300s avant considérer nouvelle instance ready
#   = Donne temps à l'application de démarrer

# COMMENT ÇA MARCHE:
# 1. ASG termine 1 instance (10%)
# 2. Lance nouvelle instance avec nouveau template
# 3. Attend 300s (warmup)
# 4. Vérifie health check
# 5. Si healthy -> continue avec instance suivante
# 6. Si unhealthy -> rollback

# Voir statut instance refresh
aws autoscaling describe-instance-refreshes \
  --auto-scaling-group-name my-web-asg

# Annuler instance refresh en cours
aws autoscaling cancel-instance-refresh \
  --auto-scaling-group-name my-web-asg

# SUPPRIMER AUTO SCALING GROUP
════════════════════════════════════════════════════════════════════════════════

# Supprimer ASG (termine toutes instances)
aws autoscaling delete-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --force-delete

# EXPLICATION:
# --force-delete
#   = Forcer suppression même si instances en cours
#   = Sans ce flag: Doit mettre min-size et desired-capacity à 0 d'abord

# Méthode "graceful" (recommandée):
# 1. Mettre capacités à 0
aws autoscaling update-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --min-size 0 \
  --max-size 0 \
  --desired-capacity 0

# 2. Attendre terminaison instances
# 3. Supprimer ASG
aws autoscaling delete-auto-scaling-group \
  --auto-scaling-group-name my-web-asg


═══════════════════════════════════════════════════════════════════════════════
[OK] SCALING POLICIES - RÈGLES DE SCALING
═══════════════════════════════════════════════════════════════════════════════

SCALING POLICY = "Règle qui dit QUAND et COMBIEN scaler"

TYPES DE POLICIES:
1. TARGET TRACKING -> "Maintenir métrique à valeur cible" (RECOMMANDÉ)
2. STEP SCALING -> "Scaler par paliers selon métrique"
3. SIMPLE SCALING -> "Scaler montant fixe" (DÉPRÉCIÉ)
4. SCHEDULED SCALING -> "Scaler à heures précises"
5. PREDICTIVE SCALING -> "Scaler selon prédictions ML"

COMPARAISON:
┌──────────────────────┬─────────────────────┬────────────────────┐
│                      │  Target Tracking    │   Step Scaling     │
├──────────────────────┼─────────────────────┼────────────────────┤
│ Simplicité           │  [OK] Très simple     │  [ATTENTION] Complexe       │
│ Cas d'usage          │  La plupart         │  Cas spéciaux      │
│ Précision            │  [OK] Bonne           │  [OK] Meilleure      │
│ Recommandation       │  [OK] Commencer ici   │  Avancé            │
└──────────────────────┴─────────────────────┴────────────────────┘

# TARGET TRACKING SCALING - LE PLUS SIMPLE (RECOMMANDÉ)
════════════════════════════════════════════════════════════════════════════════

TARGET TRACKING = "Maintenir métrique à valeur cible"

EXEMPLE:
- Métrique: CPU utilization
- Cible: 70%
- ASG scale out si CPU > 70%
- ASG scale in si CPU < 70%

AVANTAGES:
[OK] Super simple (1 seule policy)
[OK] AWS gère scaling up ET down automatiquement
[OK] Évite flapping (oscillations)
[OK] Recommandé par AWS

# Policy basée sur CPU (plus commun)
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-cpu \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 70.0
  }'

# EXPLICATION:

# --policy-type TargetTrackingScaling
#   = Type target tracking

# "PredefinedMetricSpecification"
#   = Utiliser métrique prédéfinie AWS
#   = Options disponibles:
#     * ASGAverageCPUUtilization (CPU moyen)
#     * ASGAverageNetworkIn (trafic réseau entrant)
#     * ASGAverageNetworkOut (trafic réseau sortant)
#     * ALBRequestCountPerTarget (requêtes par instance)

# "TargetValue": 70.0
#   = Valeur cible (70% CPU)
#   = ASG ajuste pour maintenir cette valeur

# COMMENT ÇA MARCHE:
# - CPU moyen = 80% -> Scale out (ajouter instances)
# - CPU moyen = 60% -> Scale in (retirer instances)
# - CPU moyen = 70% -> Rien faire (parfait!)

# RÉSULTAT:
# {
#   "PolicyARN": "arn:aws:autoscaling:us-east-1:123456789012:scalingPolicy:...",
#   "Alarms": [
#     {"AlarmName": "TargetTracking-my-web-asg-AlarmHigh-..."},
#     {"AlarmName": "TargetTracking-my-web-asg-AlarmLow-..."}
#   ]
# }

# AWS crée automatiquement 2 CloudWatch Alarms:
# - AlarmHigh: Déclenche scale out
# - AlarmLow: Déclenche scale in

# Policy basée sur requêtes ALB (Application Load Balancer)
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-alb \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ALBRequestCountPerTarget",
      "ResourceLabel": "app/my-load-balancer/50dc6c495c0c9188/targetgroup/my-targets/73e2d6bc24d8a067"
    },
    "TargetValue": 1000.0
  }'

# EXPLICATION:

# "ALBRequestCountPerTarget"
#   = Nombre requêtes par instance/minute

# "ResourceLabel"
#   = Identifiant ALB + Target Group
#   = Format: app/LB_NAME/LB_ID/targetgroup/TG_NAME/TG_ID
#   = Obtenir avec: aws elbv2 describe-load-balancers

# "TargetValue": 1000.0
#   = 1000 requêtes/instance/minute
#   = Si plus -> scale out
#   = Si moins -> scale in

# Policy basée sur métrique custom
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-custom \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "CustomizedMetricSpecification": {
      "MetricName": "QueueDepth",
      "Namespace": "MyApp",
      "Statistic": "Average"
    },
    "TargetValue": 100.0
  }'

# EXPLICATION:
# Utiliser métrique CloudWatch custom
# Exemple: Queue depth SQS, Memory utilization, etc.

# Options avancées Target Tracking
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-advanced \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 70.0,
    "ScaleInCooldown": 300,
    "ScaleOutCooldown": 60,
    "DisableScaleIn": false
  }'

# EXPLICATION OPTIONS:

# "ScaleInCooldown": 300
#   = Attendre 300s après scale in avant autre scale in
#   = Évite scale in trop agressif
#   = Défaut: 300s

# "ScaleOutCooldown": 60
#   = Attendre 60s après scale out avant autre scale out
#   = Scale out peut être plus rapide que scale in
#   = Défaut: 60s

# "DisableScaleIn": false
#   = Permettre scale in (true = seulement scale out)
#   = Use case: Black Friday (jamais scale in)

# STEP SCALING - SCALING PAR PALIERS
════════════════════════════════════════════════════════════════════════════════

STEP SCALING = "Scaler différemment selon gravité"

EXEMPLE:
- CPU 70-80% -> Ajouter 1 instance
- CPU 80-90% -> Ajouter 2 instances
- CPU > 90% -> Ajouter 4 instances

QUAND UTILISER:
- Besoin contrôle précis
- Patterns complexes
- Réaction plus rapide que Target Tracking

# Créer CloudWatch Alarm d'abord
aws cloudwatch put-metric-alarm \
  --alarm-name high-cpu-alarm \
  --alarm-description "CPU above 70%" \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --statistic Average \
  --period 60 \
  --evaluation-periods 2 \
  --threshold 70 \
  --comparison-operator GreaterThanThreshold \
  --dimensions Name=AutoScalingGroupName,Value=my-web-asg

# EXPLICATION ALARM:
# --period 60 = Vérifier chaque 60 secondes
# --evaluation-periods 2 = 2 périodes consécutives > 70%
# --threshold 70 = Seuil 70%
# Résultat: Alarme si CPU > 70% pendant 2 minutes

# Créer Step Scaling Policy
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name scale-out-steps \
  --policy-type StepScaling \
  --adjustment-type PercentChangeInCapacity \
  --metric-aggregation-type Average \
  --step-adjustments '[
    {
      "MetricIntervalLowerBound": 0,
      "MetricIntervalUpperBound": 10,
      "ScalingAdjustment": 10
    },
    {
      "MetricIntervalLowerBound": 10,
      "MetricIntervalUpperBound": 20,
      "ScalingAdjustment": 20
    },
    {
      "MetricIntervalLowerBound": 20,
      "ScalingAdjustment": 30
    }
  ]' \
  --cooldown 300

# EXPLICATION:

# --adjustment-type PercentChangeInCapacity
#   = Ajustement en pourcentage
#   = Options:
#     * ChangeInCapacity: Nombre absolu (ex: +2 instances)
#     * PercentChangeInCapacity: Pourcentage (ex: +20%)
#     * ExactCapacity: Nombre exact (ex: 10 instances)

# --metric-aggregation-type Average
#   = Comment agréger métrique
#   = Average, Minimum, Maximum

# STEP ADJUSTMENTS:
# Seuil alarme = 70% CPU

# Step 1: CPU 70-80% (breach de 0-10%)
#   -> +10% instances
#   -> Si 10 instances -> 11 instances

# Step 2: CPU 80-90% (breach de 10-20%)
#   -> +20% instances
#   -> Si 10 instances -> 12 instances

# Step 3: CPU > 90% (breach > 20%)
#   -> +30% instances
#   -> Si 10 instances -> 13 instances

# "MetricIntervalLowerBound": 0
#   = Borne inférieure relative au seuil
#   = 0 = exactement au seuil (70%)

# "MetricIntervalUpperBound": 10
#   = Borne supérieure relative au seuil
#   = 10 = seuil + 10% (80%)

# "ScalingAdjustment": 10
#   = Montant ajustement (10%)

# Lier Alarm et Policy
aws cloudwatch put-metric-alarm \
  --alarm-name high-cpu-alarm \
  --alarm-actions arn:aws:autoscaling:us-east-1:123456789012:scalingPolicy:...

# Step Scaling pour scale IN
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name scale-in-steps \
  --policy-type StepScaling \
  --adjustment-type PercentChangeInCapacity \
  --step-adjustments '[
    {
      "MetricIntervalUpperBound": 0,
      "MetricIntervalLowerBound": -10,
      "ScalingAdjustment": -10
    },
    {
      "MetricIntervalUpperBound": -10,
      "ScalingAdjustment": -20
    }
  ]'

# EXPLICATION SCALE IN:
# Seuil = 30% CPU

# Step 1: CPU 20-30% (breach de -10 à 0)
#   -> -10% instances

# Step 2: CPU < 20% (breach < -10)
#   -> -20% instances

# SIMPLE SCALING - DÉPRÉCIÉ (NE PAS UTILISER)
════════════════════════════════════════════════════════════════════════════════

# [ATTENTION] AWS recommande Target Tracking ou Step Scaling
# Simple Scaling conservé pour compatibilité seulement

aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name simple-scale-out \
  --scaling-adjustment 1 \
  --adjustment-type ChangeInCapacity \
  --cooldown 300

# PROBLÈMES SIMPLE SCALING:
# - Cooldown période bloque TOUS les scaling
# - Pas de scale différencié selon gravité
# - Moins réactif

# SCHEDULED SCALING - SCALING PLANIFIÉ
════════════════════════════════════════════════════════════════════════════════

SCHEDULED SCALING = "Scaler à heures précises"

USE CASES:
- Heures de pointe prévisibles
- Heures de bureau (9h-18h)
- Weekend vs semaine
- Black Friday, événements

# Scaler le matin (augmenter capacité)
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name my-web-asg \
  --scheduled-action-name scale-up-morning \
  --recurrence "0 9 * * MON-FRI" \
  --min-size 4 \
  --max-size 20 \
  --desired-capacity 8

# EXPLICATION:

# --recurrence "0 9 * * MON-FRI"
#   = Format Cron
#   = 0 = minute 0
#   = 9 = 9h du matin
#   = * = tous les jours du mois
#   = * = tous les mois
#   = MON-FRI = Lundi à Vendredi
#   = Résultat: Tous les jours ouvrables à 9h

# FORMAT CRON:
# minute hour day-of-month month day-of-week
# 0-59   0-23 1-31         1-12  0-6 (0=dimanche)

# Capacités appliquées à cette heure:
# - min-size: 4
# - max-size: 20
# - desired-capacity: 8
# ASG lance instances pour atteindre 8

# Scaler le soir (réduire capacité)
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name my-web-asg \
  --scheduled-action-name scale-down-evening \
  --recurrence "0 18 * * MON-FRI" \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 2

# EXPLICATION:
# Tous les jours à 18h
# Réduire à 2 instances (économie nuit)

# Action unique (pas récurrente)
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name my-web-asg \
  --scheduled-action-name black-friday-prep \
  --start-time "2024-11-29T00:00:00Z" \
  --min-size 10 \
  --max-size 50 \
  --desired-capacity 20

# EXPLICATION:
# --start-time = Date/heure précise (format ISO 8601)
# Action unique le 29 novembre 2024 à minuit UTC
# Préparer pour Black Friday

# Avec end time (fenêtre temporelle)
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name my-web-asg \
  --scheduled-action-name weekend-scale-down \
  --recurrence "0 0 * * SAT" \
  --start-time "2024-01-01T00:00:00Z" \
  --end-time "2024-12-31T23:59:59Z" \
  --min-size 1 \
  --max-size 5 \
  --desired-capacity 1

# EXPLICATION:
# Tous les samedis à minuit
# Mais seulement pendant 2024
# Après 2024 -> action ne s'exécute plus

# EXEMPLES CRON PATTERNS
════════════════════════════════════════════════════════════════════════════════

# Tous les jours à 8h
"0 8 * * *"

# Tous les lundis à 9h
"0 9 * * MON"

# Premier jour du mois à minuit
"0 0 1 * *"

# Toutes les heures
"0 * * * *"

# Toutes les 30 minutes
"0,30 * * * *"

# Weekend (samedi et dimanche) à 10h
"0 10 * * SAT,SUN"

# Dernier jour du mois (tricky - utiliser Lambda)
# Cron ne supporte pas directement

# LISTER SCHEDULED ACTIONS
════════════════════════════════════════════════════════════════════════════════

# Lister toutes les scheduled actions
aws autoscaling describe-scheduled-actions \
  --auto-scaling-group-name my-web-asg

# Format lisible
aws autoscaling describe-scheduled-actions \
  --auto-scaling-group-name my-web-asg \
  --query 'ScheduledUpdateGroupActions[*].[ScheduledActionName,Recurrence,MinSize,MaxSize,DesiredCapacity]' \
  --output table

# SUPPRIMER SCHEDULED ACTION
════════════════════════════════════════════════════════════════════════════════

aws autoscaling delete-scheduled-action \
  --auto-scaling-group-name my-web-asg \
  --scheduled-action-name scale-up-morning

# PREDICTIVE SCALING - MACHINE LEARNING
════════════════════════════════════════════════════════════════════════════════

PREDICTIVE SCALING = "AWS ML prédit charge future et scale proactivement"

AVANTAGES:
[OK] Scale AVANT pic de charge (pas après)
[OK] ML apprend patterns historiques
[OK] Combine avec Target Tracking

PRÉREQUIS:
- Au moins 24h données historiques
- Patterns répétitifs (journaliers, hebdomadaires)

aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name predictive-scaling \
  --policy-type PredictiveScaling \
  --predictive-scaling-configuration '{
    "MetricSpecifications": [
      {
        "TargetValue": 70.0,
        "PredefinedMetricPairSpecification": {
          "PredefinedMetricType": "ASGCPUUtilization"
        }
      }
    ],
    "Mode": "ForecastAndScale",
    "SchedulingBufferTime": 600
  }'

# EXPLICATION:

# "Mode": "ForecastAndScale"
#   = Prédire ET scaler automatiquement
#   = Options:
#     * ForecastOnly: Seulement prédire (pas scaler)
#     * ForecastAndScale: Prédire + scaler

# "SchedulingBufferTime": 600
#   = Scaler 600s (10 min) AVANT pic prédit
#   = Donne temps aux instances de démarrer

# COMMENT ÇA MARCHE:
# 1. ML analyse patterns CPU dernières semaines
# 2. Prédit: "Demain 12h, CPU va monter à 85%"
# 3. À 11h50, ASG scale out proactivement
# 4. À 12h, instances prêtes pour charge

# LISTER SCALING POLICIES
════════════════════════════════════════════════════════════════════════════════

# Lister toutes les policies d'un ASG
aws autoscaling describe-policies \
  --auto-scaling-group-name my-web-asg

# Format lisible
aws autoscaling describe-policies \
  --auto-scaling-group-name my-web-asg \
  --query 'ScalingPolicies[*].[PolicyName,PolicyType,Enabled]' \
  --output table

# RÉSULTAT EXEMPLE:
# -------------------------------------------------------------------------
# | target-tracking-cpu     | TargetTrackingScaling | true  |
# | scale-out-steps         | StepScaling           | true  |
# | predictive-scaling      | PredictiveScaling     | true  |
# -------------------------------------------------------------------------

# Obtenir policy spécifique
aws autoscaling describe-policies \
  --auto-scaling-group-name my-web-asg \
  --policy-names target-tracking-cpu

# SUPPRIMER SCALING POLICY
════════════════════════════════════════════════════════════════════════════════

aws autoscaling delete-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-cpu

# EXPLICATION:
# CloudWatch Alarms associées supprimées automatiquement


═══════════════════════════════════════════════════════════════════════════════
[OK] LIFECYCLE HOOKS - ACTIONS PERSONNALISÉES
═══════════════════════════════════════════════════════════════════════════════

LIFECYCLE HOOK = "Pause scaling pour exécuter actions custom"

USE CASES:
- Enregistrer instance dans système externe
- Télécharger données/config avant servir trafic
- Sauvegarder logs avant terminer instance
- Dé-enregistrer de DNS custom

ÉTATS LIFECYCLE:
1. Pending -> Hook -> InService (lancement)
2. InService -> Hook -> Terminating (terminaison)

# Créer Lifecycle Hook (au lancement)
aws autoscaling put-lifecycle-hook \
  --lifecycle-hook-name setup-hook \
  --auto-scaling-group-name my-web-asg \
  --lifecycle-transition autoscaling:EC2_INSTANCE_LAUNCHING \
  --default-result CONTINUE \
  --heartbeat-timeout 300 \
  --notification-target-arn arn:aws:sns:us-east-1:123456789012:my-topic

# EXPLICATION:

# --lifecycle-transition
#   = Quand déclencher hook
#   = Options:
#     * autoscaling:EC2_INSTANCE_LAUNCHING (au lancement)
#     * autoscaling:EC2_INSTANCE_TERMINATING (avant terminaison)

# --default-result CONTINUE
#   = Que faire si timeout
#   = Options:
#     * CONTINUE: Continuer (lancer/terminer instance)
#     * ABANDON: Abandonner (ne pas lancer/terminer)

# --heartbeat-timeout 300
#   = Temps maximum pour compléter action (secondes)
#   = Après 300s -> default-result appliqué

# --notification-target-arn
#   = SNS topic pour notifications
#   = Lambda peut écouter et exécuter actions

# COMMENT ÇA MARCHE:
# 1. ASG décide lancer nouvelle instance
# 2. Instance lancée mais état = Pending:Wait
# 3. SNS notification envoyée
# 4. Lambda/script exécute actions (install software, etc.)
# 5. Script appelle complete-lifecycle-action
# 6. Instance passe à InService

# Lifecycle Hook (avant terminaison)
aws autoscaling put-lifecycle-hook \
  --lifecycle-hook-name cleanup-hook \
  --auto-scaling-group-name my-web-asg \
  --lifecycle-transition autoscaling:EC2_INSTANCE_TERMINATING \
  --default-result CONTINUE \
  --heartbeat-timeout 600

# USE CASE:
# Sauvegarder logs vers S3 avant terminer instance

# Compléter Lifecycle Action (depuis Lambda/script)
aws autoscaling complete-lifecycle-action \
  --lifecycle-hook-name setup-hook \
  --auto-scaling-group-name my-web-asg \
  --lifecycle-action-result CONTINUE \
  --instance-id i-0123456789abcdef0

# EXPLICATION:
# --lifecycle-action-result
#   = CONTINUE: Instance passe à InService
#   = ABANDON: Instance terminée

# Envoyer heartbeat (étendre timeout)
aws autoscaling record-lifecycle-action-heartbeat \
  --lifecycle-hook-name setup-hook \
  --auto-scaling-group-name my-web-asg \
  --instance-id i-0123456789abcdef0

# EXPLICATION:
# Réinitialise timeout
# Use case: Action prend plus de temps que prévu

# Lister Lifecycle Hooks
aws autoscaling describe-lifecycle-hooks \
  --auto-scaling-group-name my-web-asg

# Supprimer Lifecycle Hook
aws autoscaling delete-lifecycle-hook \
  --lifecycle-hook-name setup-hook \
  --auto-scaling-group-name my-web-asg


═══════════════════════════════════════════════════════════════════════════════
[OK] WARM POOLS - INSTANCES PRÉ-INITIALISÉES
═══════════════════════════════════════════════════════════════════════════════

WARM POOL = "Pool d'instances pré-initialisées prêtes à servir"

PROBLÈME:
- Lancer instance = 2-5 minutes
- Pendant ce temps = capacité insuffisante
- Applications avec long startup = pire

SOLUTION: WARM POOL
- Instances pré-lancées en état "stopped" ou "hibernated"
- Quand scaling needed -> démarrer instance (30 secondes)
- Beaucoup plus rapide!

ÉTATS:
- Stopped: Instance arrêtée (pas de coût compute)
- Hibernated: RAM sauvegardée sur disque (startup ultra-rapide)
- Running: Instance en cours (coût normal)

# Créer Warm Pool
aws autoscaling put-warm-pool \
  --auto-scaling-group-name my-web-asg \
  --max-group-prepared-capacity 10 \
  --min-size 2 \
  --pool-state Stopped

# EXPLICATION:

# --max-group-prepared-capacity 10
#   = Maximum instances (ASG + Warm Pool)
#   = Si ASG a 6 instances -> Warm Pool max 4
#   = Limite coûts totaux

# --min-size 2
#   = Minimum instances dans Warm Pool
#   = Toujours 2 instances prêtes

# --pool-state Stopped
#   = État instances dans pool
#   = Options:
#     * Stopped: Arrêtées (coût EBS seulement)
#     * Hibernated: Hibernées (RAM -> disque, startup 30s)
#     * Running: En cours (coût normal, pas recommandé)

# COMMENT ÇA MARCHE:
# 1. Warm Pool: 2 instances stopped
# 2. ASG: 4 instances InService
# 3. Scaling policy déclenche: Need +2 instances
# 4. ASG démarre 2 instances du Warm Pool (~30s)
# 5. ASG lance 2 nouvelles instances pour Warm Pool

# Warm Pool avec Hibernation (plus rapide)
aws autoscaling put-warm-pool \
  --auto-scaling-group-name my-web-asg \
  --max-group-prepared-capacity 15 \
  --min-size 3 \
  --pool-state Hibernated \
  --instance-reuse-policy '{
    "ReuseOnScaleIn": true
  }'

# EXPLICATION HIBERNATION:

# --pool-state Hibernated
#   = RAM sauvegardée sur EBS
#   = Démarrage: 30 secondes (vs 2-5 minutes)
#   = Application déjà chargée en RAM!
#   = [ATTENTION] Nécessite hibernation activée dans launch template

# "ReuseOnScaleIn": true
#   = Quand scale in, instances retournent au Warm Pool
#   = Si false, instances terminées complètement
#   = true = économie (réutiliser instances)

# COÛTS WARM POOL:
# Stopped: EBS seulement (~$10/mois par instance)
# Hibernated: EBS + snapshot RAM (~$15/mois)
# Running: Coût normal (~$7-50/mois selon type)

# Voir Warm Pool
aws autoscaling describe-warm-pool \
  --auto-scaling-group-name my-web-asg

# Supprimer Warm Pool
aws autoscaling delete-warm-pool \
  --auto-scaling-group-name my-web-asg

# [ATTENTION] Instances dans pool sont terminées


═══════════════════════════════════════════════════════════════════════════════
[OK] MONITORING & MÉTRIQUES
═══════════════════════════════════════════════════════════════════════════════

# MÉTRIQUES AUTO SCALING (CloudWatch)
════════════════════════════════════════════════════════════════════════════════

# Activer métriques détaillées
aws autoscaling enable-metrics-collection \
  --auto-scaling-group-name my-web-asg \
  --granularity "1Minute" \
  --metrics GroupMinSize GroupMaxSize GroupDesiredCapacity GroupInServiceInstances GroupPendingInstances GroupTerminatingInstances

# MÉTRIQUES DISPONIBLES:
# - GroupMinSize: Min size configuré
# - GroupMaxSize: Max size configuré
# - GroupDesiredCapacity: Desired capacity actuel
# - GroupInServiceInstances: Instances en service
# - GroupPendingInstances: Instances en cours de lancement
# - GroupStandbyInstances: Instances en standby
# - GroupTerminatingInstances: Instances en terminaison
# - GroupTotalInstances: Total toutes instances

# Voir métriques dans CloudWatch
aws cloudwatch get-metric-statistics \
  --namespace AWS/AutoScaling \
  --metric-name GroupInServiceInstances \
  --dimensions Name=AutoScalingGroupName,Value=my-web-asg \
  --start-time 2024-01-15T00:00:00Z \
  --end-time 2024-01-16T00:00:00Z \
  --period 3600 \
  --statistics Average,Maximum,Minimum

# Désactiver métriques
aws autoscaling disable-metrics-collection \
  --auto-scaling-group-name my-web-asg

# CRÉER CLOUDWATCH DASHBOARD
════════════════════════════════════════════════════════════════════════════════

# Dashboard pour monitoring ASG
aws cloudwatch put-dashboard \
  --dashboard-name AutoScaling-Dashboard \
  --dashboard-body '{
    "widgets": [
      {
        "type": "metric",
        "properties": {
          "metrics": [
            ["AWS/AutoScaling", "GroupDesiredCapacity", {"stat": "Average"}],
            [".", "GroupInServiceInstances", {"stat": "Average"}],
            [".", "GroupMinSize", {"stat": "Average"}],
            [".", "GroupMaxSize", {"stat": "Average"}]
          ],
          "period": 300,
          "stat": "Average",
          "region": "us-east-1",
          "title": "Auto Scaling Group Capacity"
        }
      },
      {
        "type": "metric",
        "properties": {
          "metrics": [
            ["AWS/EC2", "CPUUtilization", {"stat": "Average"}]
          ],
          "period": 300,
          "stat": "Average",
          "region": "us-east-1",
          "title": "Average CPU Utilization"
        }
      }
    ]
  }'

# ALARMES CLOUDWATCH
════════════════════════════════════════════════════════════════════════════════

# Alarme si ASG atteint max capacity
aws cloudwatch put-metric-alarm \
  --alarm-name asg-at-max-capacity \
  --alarm-description "ASG reached maximum capacity" \
  --metric-name GroupInServiceInstances \
  --namespace AWS/AutoScaling \
  --statistic Average \
  --period 60 \
  --evaluation-periods 2 \
  --threshold 19 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --dimensions Name=AutoScalingGroupName,Value=my-web-asg \
  --alarm-actions arn:aws:sns:us-east-1:123456789012:ops-alerts

# EXPLICATION:
# Alerte équipe si ASG proche de max (20)
# Permet augmenter max-size si nécessaire

# Alarme si instances unhealthy
aws cloudwatch put-metric-alarm \
  --alarm-name unhealthy-instances \
  --alarm-description "Unhealthy instances detected" \
  --metric-name UnhealthyHostCount \
  --namespace AWS/ApplicationELB \
  --statistic Average \
  --period 60 \
  --evaluation-periods 2 \
  --threshold 1 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --alarm-actions arn:aws:sns:us-east-1:123456789012:ops-alerts

# VOIR ACTIVITÉS SCALING
════════════════════════════════════════════════════════════════════════════════

# Voir historique scaling
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --max-records 20

# Format lisible
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --max-records 10 \
  --query 'Activities[*].[StartTime,StatusCode,Description]' \
  --output table

# RÉSULTAT EXEMPLE:
# -------------------------------------------------------------------------
# | 2024-01-15T14:30:00.000Z | Successful | Launching a new EC2 instance |
# | 2024-01-15T12:15:00.000Z | Successful | Terminating EC2 instance     |
# | 2024-01-15T09:00:00.000Z | Successful | Launching a new EC2 instance |
# -------------------------------------------------------------------------

# Filtrer par période
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --start-time 2024-01-15T00:00:00Z \
  --end-time 2024-01-16T00:00:00Z


═══════════════════════════════════════════════════════════════════════════════
[OK] INTEGRATION AVEC LOAD BALANCER
═══════════════════════════════════════════════════════════════════════════════

# CRÉER APPLICATION LOAD BALANCER (ALB)
════════════════════════════════════════════════════════════════════════════════

# Créer ALB
aws elbv2 create-load-balancer \
  --name my-web-alb \
  --subnets subnet-public1 subnet-public2 \
  --security-groups sg-alb \
  --scheme internet-facing \
  --type application \
  --ip-address-type ipv4

# Notez LoadBalancerArn: arn:aws:elasticloadbalancing:...

# Créer Target Group
aws elbv2 create-target-group \
  --name my-web-targets \
  --protocol HTTP \
  --port 80 \
  --vpc-id vpc-0123456789abcdef0 \
  --health-check-enabled \
  --health-check-protocol HTTP \
  --health-check-path /health \
  --health-check-interval-seconds 30 \
  --health-check-timeout-seconds 5 \
  --healthy-threshold-count 2 \
  --unhealthy-threshold-count 3

# Notez TargetGroupArn: arn:aws:elasticloadbalancing:...

# Créer Listener
aws elbv2 create-listener \
  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/my-web-alb/... \
  --protocol HTTP \
  --port 80 \
  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-web-targets/...

# ATTACHER ASG À LOAD BALANCER
════════════════════════════════════════════════════════════════════════════════

# Méthode 1: Lors création ASG
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --launch-template LaunchTemplateName=web-template,Version='$Latest' \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 4 \
  --vpc-zone-identifier "subnet-1,subnet-2" \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-web-targets/... \
  --health-check-type ELB \
  --health-check-grace-period 300

# EXPLICATION:
# --target-group-arns = Target group du ALB
# --health-check-type ELB = Utiliser health checks ALB
# --health-check-grace-period 300 = Attendre 5 min avant health check

# Méthode 2: Attacher à ASG existant
aws autoscaling attach-load-balancer-target-groups \
  --auto-scaling-group-name my-web-asg \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-web-targets/...

# COMMENT ÇA MARCHE:
# 1. ASG lance nouvelle instance
# 2. Instance démarre et exécute user data
# 3. Attendre health-check-grace-period (300s)
# 4. ALB commence health checks (GET /health)
# 5. Si 2 health checks consécutifs OK -> instance "Healthy"
# 6. ALB commence envoyer trafic vers instance
# 7. Si health checks échouent -> instance "Unhealthy"
# 8. ASG termine instance unhealthy et lance remplacement

# Détacher Target Group
aws autoscaling detach-load-balancer-target-groups \
  --auto-scaling-group-name my-web-asg \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-web-targets/...

# INTEGRATION AVEC CLASSIC LOAD BALANCER (DÉPRÉCIÉ)
════════════════════════════════════════════════════════════════════════════════

# [ATTENTION] Classic Load Balancer déprécié - Utiliser ALB!

# Si legacy system:
aws autoscaling attach-load-balancers \
  --auto-scaling-group-name my-web-asg \
  --load-balancer-names my-classic-lb


═══════════════════════════════════════════════════════════════════════════════
[OK] BEST PRACTICES AUTO SCALING
═══════════════════════════════════════════════════════════════════════════════

# [OK] SIZING & CAPACITIES
════════════════════════════════════════════════════════════════════════════════

1. MIN SIZE
   - Au moins 2 pour haute disponibilité
   - 1 par AZ minimum
   - Jamais 0 en production!

2. MAX SIZE
   - 2-3× desired capacity normal
   - Protection contre facture surprise
   - Exemple: Desired=4 -> Max=10-12

3. DESIRED CAPACITY
   - Basé sur trafic normal
   - Laisser scaling policies ajuster
   - Ne pas modifier manuellement souvent

4. MULTIPLE AZs
   - Minimum 2 AZs (3 recommandé)
   - ASG distribue équitablement
   - Protection contre panne AZ

# [OK] SCALING POLICIES
════════════════════════════════════════════════════════════════════════════════

1. TARGET TRACKING (recommandé)
   - Plus simple à configurer
   - AWS gère complexité
   - Cible: 70% CPU (laisse marge)

2. COOLDOWN PERIODS
   - Scale out: 60-120s (rapide)
   - Scale in: 300-600s (prudent)
   - Évite scaling trop agressif

3. MULTIPLE POLICIES
   - CPU + Requêtes ALB
   - Permet réaction à différents patterns
   - AWS choisit policy la plus agressive

4. SCHEDULED SCALING
   - Pour patterns prévisibles
   - Combine avec dynamic scaling
   - Exemple: Bureau hours, weekend

# [OK] HEALTH CHECKS
════════════════════════════════════════════════════════════════════════════════

1. TYPE: ELB (recommandé)
   - Plus précis que EC2
   - Vérifie application, pas seulement instance
   - Health check path: /health ou /ping

2. GRACE PERIOD
   - 300s (5 min) minimum
   - Plus si application lente à démarrer
   - Trop court -> instances terminées prématurément

3. HEALTH CHECK ALB
   - Interval: 30s
   - Timeout: 5s
   - Healthy threshold: 2
   - Unhealthy threshold: 3
   - Path: Endpoint léger (pas DB query!)

# [OK] LAUNCH TEMPLATE
════════════════════════════════════════════════════════════════════════════════

1. VERSIONING
   - Toujours versionner
   - Tester nouvelle version avant production
   - Garder anciennes versions pour rollback

2. USER DATA
   - Idempotent (peut exécuter plusieurs fois)
   - Logger vers CloudWatch Logs
   - Rapide (< 2 minutes idéal)

3. IAM ROLE
   - Principe moindre privilège
   - Permissions spécifiques à application
   - Pas de credentials hardcodés!

4. SECURITY
   - IMDSv2 required
   - EBS encryption enabled
   - Minimal security groups

# [OK] COST OPTIMIZATION
════════════════════════════════════════════════════════════════════════════════

1. INSTANCE TYPES
   - T3/T3a pour workloads variables (burstable)
   - M5 pour workloads stables
   - C5 pour CPU-intensive
   - Graviton (T4g, M6g) = 20% moins cher!

2. SPOT INSTANCES
   - 50-90% moins cher
   - Mix on-demand + spot
   - Parfait pour stateless apps

3. SCALING POLICIES
   - Scale out rapide, scale in lent
   - Éviter flapping (coûts lancement)
   - Warmup period approprié

4. SCHEDULED ACTIONS
   - Scale down hors heures
   - Exemple: 2 instances nuit, 10 jour
   - Économie: 60-70% pour apps bureau

5. WARM POOL
   - Stopped state = coût EBS seulement
   - Plus rapide que lancer nouvelle instance
   - Économie + performance

# [OK] MONITORING
════════════════════════════════════════════════════════════════════════════════

1. MÉTRIQUES CLÉS
   - GroupDesiredCapacity
   - GroupInServiceInstances
   - CPU Utilization (par instance)
   - Target Response Time (ALB)

2. ALARMES
   - ASG at max capacity
   - Unhealthy instances
   - Frequent scaling (flapping)
   - High CPU sustained

3. LOGS
   - CloudWatch Logs pour user data
   - Scaling activities history
   - Health check failures

# [OK] TESTING
════════════════════════════════════════════════════════════════════════════════

1. LOAD TESTING
   - Vérifier scaling policy fonctionne
   - Temps scale out < 5 minutes
   - Application stable pendant scaling

2. CHAOS ENGINEERING
   - Terminer instances aléatoirement
   - ASG doit remplacer automatiquement
   - Application reste disponible

3. ROLLBACK PLAN
   - Garder anciennes versions launch template
   - Tester rollback avant production
   - Documentation procédure

# [OK] SECURITY
════════════════════════════════════════════════════════════════════════════════

1. NETWORK
   - Instances dans private subnets
   - Load Balancer dans public subnets
   - Security groups restrictifs

2. IAM
   - Instance profile avec permissions minimales
   - Pas de credentials dans user data
   - Rotation credentials régulière

3. ENCRYPTION
   - EBS encryption enabled
   - HTTPS entre ALB et instances
   - Secrets Manager pour credentials


═══════════════════════════════════════════════════════════════════════════════
[OK] TROUBLESHOOTING AUTO SCALING
═══════════════════════════════════════════════════════════════════════════════

# PROBLÈME 1: Instances ne lancent pas
════════════════════════════════════════════════════════════════════════════════

# Vérifier activités scaling
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --max-records 5

# CAUSES COMMUNES:
# 1. Launch template invalide (AMI supprimée, security group)
# 2. Quotas EC2 dépassés
# 3. Pas de capacité dans AZ
# 4. IAM role manquant

# SOLUTION:
# Vérifier launch template
aws ec2 describe-launch-template-versions \
  --launch-template-id lt-xxx \
  --versions '$Latest'

# Tester lancer instance manuellement
aws ec2 run-instances \
  --launch-template LaunchTemplateId=lt-xxx


# PROBLÈME 2: Scaling ne se déclenche pas
════════════════════════════════════════════════════════════════════════════════

# Vérifier policies
aws autoscaling describe-policies \
  --auto-scaling-group-name my-web-asg

# Vérifier alarmes CloudWatch
aws cloudwatch describe-alarms \
  --alarm-names TargetTracking-my-web-asg-AlarmHigh-...

# CAUSES:
# 1. Policy désactivée
# 2. Alarme en INSUFFICIENT_DATA
# 3. Cooldown period actif
# 4. ASG at max capacity

# SOLUTION:
# Forcer scaling manuel pour tester
aws autoscaling set-desired-capacity \
  --auto-scaling-group-name my-web-asg \
  --desired-capacity 6


# PROBLÈME 3: Instances terminées immédiatement
════════════════════════════════════════════════════════════════════════════════

# Vérifier health checks
aws autoscaling describe-auto-scaling-groups \
  --auto-scaling-group-names my-web-asg \
  --query 'AutoScalingGroups[0].Instances[*].[InstanceId,HealthStatus,LifecycleState]'

# CAUSES:
# 1. Health check grace period trop court
# 2. Application ne démarre pas assez vite
# 3. Health check endpoint échoue
# 4. Security group bloque health checks

# SOLUTION:
# Augmenter grace period
aws autoscaling update-auto-scaling-group \
  --auto-scaling-group-name my-web-asg \
  --health-check-grace-period 600

# Vérifier health check ALB
aws elbv2 describe-target-health \
  --target-group-arn arn:...


# PROBLÈME 4: Scale in trop agressif
════════════════════════════════════════════════════════════════════════════════

# CAUSE:
# Cooldown trop court ou target value trop bas

# SOLUTION:
# Augmenter scale in cooldown
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-web-asg \
  --policy-name target-tracking-cpu \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 70.0,
    "ScaleInCooldown": 600
  }'


# PROBLÈME 5: Coûts élevés
════════════════════════════════════════════════════════════════════════════════

# Voir historique scaling
aws autoscaling describe-scaling-activities \
  --auto-scaling-group-name my-web-asg \
  --max-records 50

# CAUSES:
# 1. Flapping (scale out/in répété)
# 2. Max size trop élevé
# 3. Target value trop bas
# 4. Pas de scheduled scale down

# SOLUTIONS:
# 1. Augmenter cooldown periods
# 2. Ajuster target value (60% -> 70%)
# 3. Ajouter scheduled actions (nuit/weekend)
# 4. Utiliser Spot instances


═══════════════════════════════════════════════════════════════════════════════
[OK] EXEMPLE COMPLET - ARCHITECTURE PRODUCTION
═══════════════════════════════════════════════════════════════════════════════

#!/bin/bash
# Script création Auto Scaling complet pour production

set -e

# === VARIABLES ===
ASG_NAME="production-web-asg"
REGION="us-east-1"
VPC_ID="vpc-0123456789abcdef0"
SUBNET_1="subnet-public1"
SUBNET_2="subnet-public2"
SUBNET_3="subnet-public3"

echo "=== Création Launch Template ==="

# User data
cat > user-data.sh << 'EOF'
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd

# Application web
cat > /var/www/html/index.php << 'HTML'
<?php
$instance_id = file_get_contents('http://169.254.169.254/latest/meta-data/instance-id');
$az = file_get_contents('http://169.254.169.254/latest/meta-data/placement/availability-zone');
?>
<!DOCTYPE html>
<html>
<head><title>Auto Scaling Demo</title></head>
<body>
  <h1>Servie par: <?php echo $instance_id; ?></h1>
  <p>Availability Zone: <?php echo $az; ?></p>
  <p>Load: <?php echo sys_getloadavg()[0]; ?></p>
</body>
</html>
HTML

# Health check endpoint
echo "OK" > /var/www/html/health
EOF

USER_DATA=$(base64 -w 0 user-data.sh)

# Créer Launch Template
LT_ID=$(aws ec2 create-launch-template \
  --launch-template-name $ASG_NAME-template \
  --version-description "Production v1" \
  --launch-template-data '{
    "ImageId": "ami-0c55b159cbfafe1f0",
    "InstanceType": "t3.micro",
    "KeyName": "my-key",
    "SecurityGroupIds": ["sg-web123"],
    "UserData": "'$USER_DATA'",
    "IamInstanceProfile": {"Name": "EC2-WebServer-Role"},
    "Monitoring": {"Enabled": true},
    "MetadataOptions": {
      "HttpTokens": "required",
      "HttpPutResponseHopLimit": 1
    },
    "TagSpecifications": [{
      "ResourceType": "instance",
      "Tags": [
        {"Key": "Name", "Value": "Web-Server-ASG"},
        {"Key": "Environment", "Value": "Production"}
      ]
    }]
  }' \
  --query 'LaunchTemplate.LaunchTemplateId' \
  --output text)

echo "Launch Template créé: $LT_ID"

echo "=== Création Auto Scaling Group ==="

# Créer ASG
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name $ASG_NAME \
  --launch-template LaunchTemplateId=$LT_ID,Version='$Latest' \
  --min-size 2 \
  --max-size 20 \
  --desired-capacity 4 \
  --default-cooldown 300 \
  --health-check-type ELB \
  --health-check-grace-period 300 \
  --vpc-zone-identifier "$SUBNET_1,$SUBNET_2,$SUBNET_3" \
  --target-group-arns arn:aws:elasticloadbalancing:$REGION:123456789012:targetgroup/web-targets/... \
  --termination-policies "OldestInstance" \
  --tags Key=Name,Value=Web-Server-ASG,PropagateAtLaunch=true \
         Key=Environment,Value=Production,PropagateAtLaunch=true

echo "ASG créé: $ASG_NAME"

echo "=== Configuration Scaling Policies ==="

# Target Tracking - CPU
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name $ASG_NAME \
  --policy-name target-tracking-cpu \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 70.0,
    "ScaleInCooldown": 300,
    "ScaleOutCooldown": 60
  }'

# Target Tracking - ALB Requests
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name $ASG_NAME \
  --policy-name target-tracking-alb \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ALBRequestCountPerTarget",
      "ResourceLabel": "app/my-alb/.../targetgroup/web-targets/..."
    },
    "TargetValue": 1000.0
  }'

echo "=== Configuration Scheduled Actions ==="

# Scale up le matin (heures de bureau)
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name $ASG_NAME \
  --scheduled-action-name scale-up-morning \
  --recurrence "0 8 * * MON-FRI" \
  --min-size 4 \
  --max-size 20 \
  --desired-capacity 8

# Scale down le soir
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name $ASG_NAME \
  --scheduled-action-name scale-down-evening \
  --recurrence "0 20 * * MON-FRI" \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 2

# Scale down weekend
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name $ASG_NAME \
  --scheduled-action-name scale-down-weekend \
  --recurrence "0 0 * * SAT" \
  --min-size 2 \
  --max-size 5 \
  --desired-capacity 2

echo "=== Activation Métriques ==="

aws autoscaling enable-metrics-collection \
  --auto-scaling-group-name $ASG_NAME \
  --granularity "1Minute" \
  --metrics GroupDesiredCapacity GroupInServiceInstances GroupPendingInstances

echo "=== Configuration Alarmes ==="

# Alarme max capacity
aws cloudwatch put-metric-alarm \
  --alarm-name $ASG_NAME-max-capacity \
  --alarm-description "ASG approaching max capacity" \
  --metric-name GroupInServiceInstances \
  --namespace AWS/AutoScaling \
  --statistic Average \
  --period 60 \
  --evaluation-periods 2 \
  --threshold 18 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --dimensions Name=AutoScalingGroupName,Value=$ASG_NAME \
  --alarm-actions arn:aws:sns:$REGION:123456789012:ops-alerts

echo "=== ARCHITECTURE COMPLETE ==="
echo "ASG Name: $ASG_NAME"
echo "Min: 2, Max: 20, Desired: 4"
echo "Scaling Policies: CPU (70%), ALB Requests (1000)"
echo "Scheduled: Scale up 8h, down 20h (weekdays)"


═══════════════════════════════════════════════════════════════════════════════
[OK] COMMANDES RAPIDES - QUICK REFERENCE
═══════════════════════════════════════════════════════════════════════════════

# Launch Template
aws ec2 create-launch-template --launch-template-name NAME --launch-template-data '{...}'
aws ec2 describe-launch-templates
aws ec2 delete-launch-template --launch-template-id lt-xxx

# Auto Scaling Group
aws autoscaling create-auto-scaling-group --auto-scaling-group-name NAME \
  --launch-template LaunchTemplateName=NAME,Version='$Latest' \
  --min-size 2 --max-size 10 --desired-capacity 4
  --vpc-zone-identifier "subnet-1,subnet-2"
aws autoscaling describe-auto-scaling-groups
aws autoscaling update-auto-scaling-group --auto-scaling-group-name NAME --min-size 3 --max-size 15
aws autoscaling delete-auto-scaling-group --auto-scaling-group-name NAME --force-delete

# Scaling Policies
aws autoscaling put-scaling-policy --auto-scaling-group-name NAME \
  --policy-name target-cpu --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{...}'
aws autoscaling describe-policies --auto-scaling-group-name NAME
aws autoscaling delete-policy --auto-scaling-group-name NAME --policy-name NAME

# Scheduled Actions
aws autoscaling put-scheduled-update-group-action --auto-scaling-group-name NAME \
  --scheduled-action-name NAME --recurrence "0 9 * * MON-FRI" --desired-capacity 6
aws autoscaling describe-scheduled-actions --auto-scaling-group-name NAME
aws autoscaling delete-scheduled-action --auto-scaling-group-name NAME --scheduled-action-name NAME

# Manual Scaling
aws autoscaling set-desired-capacity --auto-scaling-group-name NAME --desired-capacity 8
aws autoscaling terminate-instance-in-auto-scaling-group --instance-id i-xxx --should-decrement-desired-capacity

# Processes
aws autoscaling suspend-processes --auto-scaling-group-name NAME
aws autoscaling resume-processes --auto-scaling-group-name NAME

# Instances
aws autoscaling describe-auto-scaling-instances
aws autoscaling enter-standby --instance-ids i-xxx --auto-scaling-group-name NAME --should-decrement-desired-capacity
aws autoscaling exit-standby --instance-ids i-xxx --auto-scaling-group-name NAME

# Monitoring
aws autoscaling enable-metrics-collection --auto-scaling-group-name NAME --granularity "1Minute"
aws autoscaling describe-scaling-activities --auto-scaling-group-name NAME --max-records 10

# Load Balancer
aws autoscaling attach-load-balancer-target-groups --auto-scaling-group-name NAME --target-group-arns arn:...
aws autoscaling detach-load-balancer-target-groups --auto-scaling-group-name NAME --target-group-arns arn:...


═══════════════════════════════════════════════════════════════════════════════
[OK] SCÉNARIOS AVANCÉS
═══════════════════════════════════════════════════════════════════════════════

# SCÉNARIO 1: BLUE/GREEN DEPLOYMENT AVEC AUTO SCALING
════════════════════════════════════════════════════════════════════════════════

# Objectif: Déployer nouvelle version sans downtime

# 1. Créer nouveau Launch Template (version 2)
aws ec2 create-launch-template-version \
  --launch-template-id lt-0123456789abcdef0 \
  --version-description "Version 2 - New feature" \
  --source-version 1 \
  --launch-template-data '{
    "ImageId": "ami-NEW123",
    "UserData": "'$NEW_USER_DATA'"
  }'

# 2. Créer ASG "Green" avec nouveau template
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name green-asg \
  --launch-template LaunchTemplateId=lt-xxx,Version='2' \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 4 \
  --vpc-zone-identifier "subnet-1,subnet-2" \
  --target-group-arns arn:aws:elasticloadbalancing:...:targetgroup/green-targets/...

# 3. Attendre que instances Green soient healthy
aws autoscaling wait group-in-service \
  --auto-scaling-group-names green-asg

# 4. Basculer trafic ALB (weighted target groups)
# Blue: 100% -> 50% -> 0%
# Green: 0% -> 50% -> 100%

aws elbv2 modify-rule \
  --rule-arn arn:... \
  --actions Type=forward,ForwardConfig='{
    "TargetGroups": [
      {"TargetGroupArn": "arn:.../blue-targets/...", "Weight": 50},
      {"TargetGroupArn": "arn:.../green-targets/...", "Weight": 50}
    ]
  }'

# 5. Vérifier métriques (erreurs, latence)
# Si OK -> 100% Green
# Si problème -> Rollback 100% Blue

# 6. Basculer complètement vers Green
aws elbv2 modify-rule \
  --rule-arn arn:... \
  --actions Type=forward,TargetGroupArn=arn:.../green-targets/...

# 7. Supprimer Blue ASG
aws autoscaling delete-auto-scaling-group \
  --auto-scaling-group-name blue-asg \
  --force-delete


# SCÉNARIO 2: CANARY DEPLOYMENT (TESTER SUR 5%)
════════════════════════════════════════════════════════════════════════════════

# Déployer nouvelle version sur 5% trafic seulement

# 1. Créer Canary ASG (petite)
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name canary-asg \
  --launch-template LaunchTemplateId=lt-new,Version='$Latest' \
  --min-size 1 \
  --max-size 2 \
  --desired-capacity 1 \
  --vpc-zone-identifier "subnet-1,subnet-2" \
  --target-group-arns arn:.../canary-targets/...

# 2. Configurer ALB: 95% prod, 5% canary
aws elbv2 modify-rule \
  --rule-arn arn:... \
  --actions Type=forward,ForwardConfig='{
    "TargetGroups": [
      {"TargetGroupArn": "arn:.../prod-targets/...", "Weight": 95},
      {"TargetGroupArn": "arn:.../canary-targets/...", "Weight": 5}
    ]
  }'

# 3. Monitorer métriques canary vs prod
# CloudWatch Metrics:
# - Error rate
# - Latency p50, p99
# - CPU/Memory

# 4. Si métriques OK après 1h -> déployer complètement
# Si problème -> terminer canary

# 5. Rollout progressif
# 5% -> 25% -> 50% -> 100%


# SCÉNARIO 3: BATCH PROCESSING AVEC AUTO SCALING
════════════════════════════════════════════════════════════════════════════════

# Scale basé sur queue depth SQS

# 1. Créer métrique custom CloudWatch
# (Dans code worker, publier queue depth)

# 2. Scaling policy basé sur queue depth
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name batch-workers-asg \
  --policy-name scale-on-queue \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "CustomizedMetricSpecification": {
      "MetricName": "ApproximateNumberOfMessagesVisible",
      "Namespace": "AWS/SQS",
      "Statistic": "Average",
      "Dimensions": [
        {
          "Name": "QueueName",
          "Value": "my-processing-queue"
        }
      ]
    },
    "TargetValue": 100.0
  }'

# EXPLICATION:
# Target: 100 messages par instance
# Si queue = 1000 messages -> 10 instances
# Si queue = 50 messages -> 1 instance

# 3. Configuration ASG
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name batch-workers-asg \
  --launch-template LaunchTemplateName=worker-template,Version='$Latest' \
  --min-size 0 \
  --max-size 50 \
  --desired-capacity 0 \
  --vpc-zone-identifier "subnet-private-1,subnet-private-2"

# EXPLICATION:
# min-size 0 = Pas de workers quand queue vide
# Économie maximale


# SCÉNARIO 4: MULTI-REGION AUTO SCALING
════════════════════════════════════════════════════════════════════════════════

# Auto Scaling dans plusieurs régions

# Région 1 (us-east-1) - Primary
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name us-east-asg \
  --launch-template LaunchTemplateName=web-template,Version='$Latest' \
  --min-size 4 \
  --max-size 20 \
  --desired-capacity 8 \
  --vpc-zone-identifier "subnet-us-east-1a,subnet-us-east-1b" \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:...

# Région 2 (eu-west-1) - Secondary
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name eu-west-asg \
  --launch-template LaunchTemplateName=web-template,Version='$Latest' \
  --min-size 2 \
  --max-size 10 \
  --desired-capacity 4 \
  --vpc-zone-identifier "subnet-eu-west-1a,subnet-eu-west-1b" \
  --target-group-arns arn:aws:elasticloadbalancing:eu-west-1:... \
  --region eu-west-1

# Utiliser Route 53 pour distribuer trafic:
# - Geolocation routing: US -> us-east-1, EU -> eu-west-1
# - Latency routing: Route vers région la plus proche
# - Failover: Si us-east-1 down -> eu-west-1


# SCÉNARIO 5: SPOT + ON-DEMAND MIX (ÉCONOMIE)
════════════════════════════════════════════════════════════════════════════════

# 50% Spot (économie) + 50% On-Demand (stabilité)

aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name mixed-asg \
  --mixed-instances-policy '{
    "LaunchTemplate": {
      "LaunchTemplateSpecification": {
        "LaunchTemplateId": "lt-0123456789abcdef0",
        "Version": "$Latest"
      },
      "Overrides": [
        {"InstanceType": "t3.micro"},
        {"InstanceType": "t3.small"},
        {"InstanceType": "t3a.micro"},
        {"InstanceType": "t3a.small"}
      ]
    },
    "InstancesDistribution": {
      "OnDemandBaseCapacity": 2,
      "OnDemandPercentageAboveBaseCapacity": 50,
      "SpotAllocationStrategy": "capacity-optimized",
      "SpotInstancePools": 4,
      "SpotMaxPrice": ""
    }
  }' \
  --min-size 4 \
  --max-size 20 \
  --desired-capacity 8 \
  --vpc-zone-identifier "subnet-1,subnet-2,subnet-3"

# EXPLICATION:

# "OnDemandBaseCapacity": 2
#   = Toujours 2 instances On-Demand minimum
#   = Base stable

# "OnDemandPercentageAboveBaseCapacity": 50
#   = Au-dessus de base, 50% On-Demand, 50% Spot
#   = Si desired=8: 2 On-Demand (base) + 3 On-Demand + 3 Spot

# "SpotAllocationStrategy": "capacity-optimized"
#   = AWS choisit Spot pools avec le plus de capacité
#   = Réduit interruptions
#   = Options: lowest-price, capacity-optimized, diversified

# "SpotInstancePools": 4
#   = Diversifier sur 4 instance types différents
#   = Réduit risque interruption

# "SpotMaxPrice": ""
#   = Vide = Prix On-Demand (recommandé)
#   = Ou spécifier max price

# ÉCONOMIE:
# On-Demand t3.micro: $0.0104/h
# Spot t3.micro: ~$0.0031/h (70% économie)
# Mix 50/50: ~35% économie totale


# SCÉNARIO 6: GAMING - SCALE RAPIDE POUR ÉVÉNEMENTS
════════════════════════════════════════════════════════════════════════════════

# Jeu avec événements spéciaux (tournois)

# Configuration normale
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name game-servers-asg \
  --launch-template LaunchTemplateName=game-server,Version='$Latest' \
  --min-size 10 \
  --max-size 100 \
  --desired-capacity 20 \
  --vpc-zone-identifier "subnet-1,subnet-2,subnet-3"

# Scaling ultra-agressif
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name game-servers-asg \
  --policy-name fast-scale-out \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 60.0,
    "ScaleOutCooldown": 30
  }'

# Warm Pool pour démarrage rapide
aws autoscaling put-warm-pool \
  --auto-scaling-group-name game-servers-asg \
  --max-group-prepared-capacity 120 \
  --min-size 20 \
  --pool-state Hibernated

# Scheduled action pour tournoi
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name game-servers-asg \
  --scheduled-action-name tournament-prep \
  --start-time "2024-06-15T19:00:00Z" \
  --min-size 50 \
  --max-size 200 \
  --desired-capacity 80

# EXPLICATION:
# 19h: Scale up avant tournoi (20h)
# Warm Pool: 20 servers prêts (30s startup)
# Cooldown: 30s (scale rapide)
# Max: 200 servers pour pic


# SCÉNARIO 7: MACHINE LEARNING TRAINING
════════════════════════════════════════════════════════════════════════════════

# Cluster training avec GPU instances

aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name ml-training-asg \
  --mixed-instances-policy '{
    "LaunchTemplate": {
      "LaunchTemplateSpecification": {
        "LaunchTemplateId": "lt-gpu-template",
        "Version": "$Latest"
      },
      "Overrides": [
        {"InstanceType": "g4dn.xlarge"},
        {"InstanceType": "g4dn.2xlarge"},
        {"InstanceType": "g5.xlarge"}
      ]
    },
    "InstancesDistribution": {
      "OnDemandBaseCapacity": 0,
      "OnDemandPercentageAboveBaseCapacity": 0,
      "SpotAllocationStrategy": "capacity-optimized"
    }
  }' \
  --min-size 0 \
  --max-size 20 \
  --desired-capacity 0 \
  --vpc-zone-identifier "subnet-private-1,subnet-private-2"

# EXPLICATION:
# 100% Spot (économie maximale)
# min-size 0 = Pas de coût quand pas de training
# Démarrer manuellement pour training:

aws autoscaling set-desired-capacity \
  --auto-scaling-group-name ml-training-asg \
  --desired-capacity 10

# Après training terminé:
aws autoscaling set-desired-capacity \
  --auto-scaling-group-name ml-training-asg \
  --desired-capacity 0

# ÉCONOMIE:
# g4dn.xlarge On-Demand: $0.526/h
# g4dn.xlarge Spot: ~$0.158/h (70% économie)
# 10 instances × 8h training = $12.64 (vs $42.08)


═══════════════════════════════════════════════════════════════════════════════
[OK] COÛTS AUTO SCALING - CALCULATEUR
═══════════════════════════════════════════════════════════════════════════════

# AUTO SCALING = GRATUIT!
# Vous payez seulement pour les instances EC2

# EXEMPLE CALCUL:
════════════════════════════════════════════════════════════════════════════════

# Configuration:
# - Type: t3.micro ($0.0104/h)
# - Min: 2, Max: 10
# - Trafic: Variable

# SCÉNARIO 1: SANS AUTO SCALING
# Provisionner pour pic: 10 instances 24/7
# Coût: 10 × $0.0104 × 730h = $75.92/mois
# Utilisation réelle: 30% du temps
# Gaspillage: $53.14/mois

# SCÉNARIO 2: AVEC AUTO SCALING
# Heures bureau (8h-18h, 5j/sem): 8 instances
# Heure creuse (18h-8h): 2 instances
# Weekend: 2 instances

# Calcul:
# - Bureau: 50h/sem × 8 inst = 400 inst-h/sem
# - Creuse: 70h/sem × 2 inst = 140 inst-h/sem
# - Weekend: 48h/sem × 2 inst = 96 inst-h/sem
# Total: 636 inst-h/sem × 4.3 sem = 2,735 inst-h/mois

# Coût: 2,735 × $0.0104 = $28.44/mois
# ÉCONOMIE: $47.48/mois (62%)

# SCÉNARIO 3: AVEC SPOT INSTANCES
# Mix: 50% On-Demand, 50% Spot
# Spot price: $0.0031/h (70% économie)

# Calcul:
# - 50% On-Demand: 1,368 inst-h × $0.0104 = $14.23
# - 50% Spot: 1,368 inst-h × $0.0031 = $4.24
# Total: $18.47/mois
# ÉCONOMIE: $57.45/mois (76% vs sans Auto Scaling)

# CALCULATOR SCRIPT
════════════════════════════════════════════════════════════════════════════════

#!/bin/bash
# Calculateur coût Auto Scaling

# Variables
INSTANCE_TYPE="t3.micro"
ON_DEMAND_PRICE=0.0104  # $/heure
SPOT_PRICE=0.0031       # $/heure (70% discount)

# Heures par semaine
BUSINESS_HOURS=50       # 8h-18h × 5 jours
OFF_HOURS=70           # 18h-8h × 5 jours
WEEKEND_HOURS=48       # 24h × 2 jours

# Instances par période
BUSINESS_INSTANCES=8
OFF_INSTANCES=2
WEEKEND_INSTANCES=2

# Calcul instance-heures par mois
WEEKS_PER_MONTH=4.3

BUSINESS_INST_H=$(echo "$BUSINESS_HOURS * $BUSINESS_INSTANCES * $WEEKS_PER_MONTH" | bc)
OFF_INST_H=$(echo "$OFF_HOURS * $OFF_INSTANCES * $WEEKS_PER_MONTH" | bc)
WEEKEND_INST_H=$(echo "$WEEKEND_HOURS * $WEEKEND_INSTANCES * $WEEKS_PER_MONTH" | bc)

TOTAL_INST_H=$(echo "$BUSINESS_INST_H + $OFF_INST_H + $WEEKEND_INST_H" | bc)

# Coût 100% On-Demand
COST_ON_DEMAND=$(echo "$TOTAL_INST_H * $ON_DEMAND_PRICE" | bc)

# Coût Mix 50/50
HALF_INST_H=$(echo "$TOTAL_INST_H / 2" | bc)
COST_MIX=$(echo "($HALF_INST_H * $ON_DEMAND_PRICE) + ($HALF_INST_H * $SPOT_PRICE)" | bc)

# Coût sans Auto Scaling (10 instances 24/7)
HOURS_PER_MONTH=730
COST_NO_ASG=$(echo "10 * $ON_DEMAND_PRICE * $HOURS_PER_MONTH" | bc)

echo "=== CALCULATEUR COÛT AUTO SCALING ==="
echo ""
echo "Instance Type: $INSTANCE_TYPE"
echo "Total instance-heures/mois: $TOTAL_INST_H"
echo ""
echo "SANS Auto Scaling (10 inst 24/7):"
echo "  Coût: \$$COST_NO_ASG/mois"
echo ""
echo "AVEC Auto Scaling (100% On-Demand):"
echo "  Coût: \$$COST_ON_DEMAND/mois"
SAVINGS=$(echo "$COST_NO_ASG - $COST_ON_DEMAND" | bc)
PERCENT=$(echo "scale=1; ($SAVINGS / $COST_NO_ASG) * 100" | bc)
echo "  Économie: \$$SAVINGS/mois ($PERCENT%)"
echo ""
echo "AVEC Auto Scaling + Spot (50/50):"
echo "  Coût: \$$COST_MIX/mois"
SAVINGS_SPOT=$(echo "$COST_NO_ASG - $COST_MIX" | bc)
PERCENT_SPOT=$(echo "scale=1; ($SAVINGS_SPOT / $COST_NO_ASG) * 100" | bc)
echo "  Économie: \$$SAVINGS_SPOT/mois ($PERCENT_SPOT%)"


═══════════════════════════════════════════════════════════════════════════════
[OK] RESSOURCES UTILES
═══════════════════════════════════════════════════════════════════════════════

# Documentation officielle
https://docs.aws.amazon.com/autoscaling/

# Auto Scaling Best Practices
https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-best-practices.html

# Pricing Calculator
https://calculator.aws/#/

# Instance Types & Pricing
https://aws.amazon.com/ec2/instance-types/
https://aws.amazon.com/ec2/pricing/

# Spot Instance Pricing History
https://aws.amazon.com/ec2/spot/pricing/

# CloudWatch Metrics
https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-monitoring.html

# Launch Template User Guide
https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html

# Scaling Policy Types
https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scale-based-on-demand.html

# Lifecycle Hooks
https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html

# Warm Pools
https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-warm-pools.html

# AWS CLI Reference
https://awscli.amazonaws.com/v2/documentation/api/latest/reference/autoscaling/index.html

# Service Quotas
https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html

# AWS Forums (community support)
https://forums.aws.amazon.com/forum.jspa?forumID=61


═══════════════════════════════════════════════════════════════════════════════
[OK] GLOSSAIRE
═══════════════════════════════════════════════════════════════════════════════

ASG: Auto Scaling Group
AZ: Availability Zone
ALB: Application Load Balancer
ELB: Elastic Load Balancer
ENI: Elastic Network Interface
IAM: Identity and Access Management
IMDSv2: Instance Metadata Service version 2
LT: Launch Template
SG: Security Group
VPC: Virtual Private Cloud

CAPACITY: Nombre d'instances
COOLDOWN: Période d'attente après scaling
DESIRED CAPACITY: Nombre d'instances souhaité actuellement
FLAPPING: Scaling up/down répété (oscillation)
GRACE PERIOD: Délai avant health checks
HEALTH CHECK: Vérification santé instance
LAUNCH TEMPLATE: Modèle pour créer instances
MAX SIZE: Capacité maximum
MIN SIZE: Capacité minimum
SCALE IN: Retirer instances
SCALE OUT: Ajouter instances
SPOT INSTANCE: Instance jusqu'à 90% moins chère (interruptible)
TARGET TRACKING: Maintenir métrique à valeur cible
WARM POOL: Pool d'instances pré-initialisées
WEIGHTED CAPACITY: Poids d'un instance type


═══════════════════════════════════════════════════════════════════════════════
[OK] CHECKLIST DÉPLOIEMENT PRODUCTION
═══════════════════════════════════════════════════════════════════════════════

AVANT LANCEMENT:
[ ] Launch Template testé manuellement
[ ] User data fonctionne correctement
[ ] AMI à jour avec derniers patches
[ ] Security Groups configurés (moindre privilège)
[ ] IAM Role avec permissions minimales
[ ] Health check endpoint répond (/health)
[ ] Min size ≥ 2 (haute disponibilité)
[ ] Multiple AZs configurées (≥ 2)
[ ] Load Balancer configuré et testé
[ ] Target Group health checks OK
[ ] Scaling policies testées
[ ] CloudWatch alarmes créées
[ ] SNS notifications configurées
[ ] Documentation à jour

APRÈS LANCEMENT:
[ ] Vérifier instances lancent correctement
[ ] Vérifier health checks passent
[ ] Tester scaling up/down manuellement
[ ] Load testing (simuler trafic)
[ ] Vérifier métriques CloudWatch
[ ] Tester failover (terminer instance)
[ ] Vérifier logs CloudWatch
[ ] Documenter configuration
[ ] Former équipe ops
[ ] Plan rollback prêt

MONITORING CONTINU:
[ ] Daily: Vérifier ASG healthy
[ ] Daily: Review scaling activities
[ ] Weekly: Review coûts
[ ] Weekly: Review métriques performance
[ ] Monthly: Review scaling policies
[ ] Monthly: Tester disaster recovery
[ ] Quarterly: Update AMIs
[ ] Quarterly: Review architecture