# Fichier: python_cheats/cheatsheets/EC2.txt
# Cheatsheet AWS EC2 - Guide Complet pour Débutants


═══════════════════════════════════════════════════════════════════════════════
[OK] EC2 (ELASTIC COMPUTE CLOUD) - C'EST QUOI?
═══════════════════════════════════════════════════════════════════════════════

EC2 = "Ordinateurs virtuels dans le cloud"

Imaginez que vous pouvez louer des ordinateurs sur internet:
- Au lieu d'acheter un serveur physique (cher, lourd, à maintenir)
- Vous payez pour utiliser un ordinateur virtuel chez AWS
- Vous pouvez le démarrer, l'arrêter, le modifier quand vous voulez
- Parfait pour héberger des sites, des applications, des APIs, etc.

ANALOGIE: C'est comme louer une chambre d'hôtel
- Vous n'êtes pas propriétaire du bâtiment
- Vous payez par nuit d'utilisation
- Vous pouvez partir quand vous voulez
- L'hôtel gère la maintenance

TERMINOLOGIE DE BASE:
- Instance = 1 ordinateur virtuel (c'est ce que vous louerez)
- AMI = Image/Système d'exploitation (Ubuntu, Amazon Linux, Windows, etc.)
- Instance type = Puissance de l'ordi (t2.micro = petit, m5.large = plus gros)
- Region = Localisation géographique (us-east-1, eu-west-1, etc.)
- Security Group = Pare-feu (contrôle qui peut se connecter)
- Key Pair = Clé SSH (pour se connecter en SSH sans mot de passe)
- Elastic IP = Adresse IP fixe (IP ne change pas si vous redémarrez)


═══════════════════════════════════════════════════════════════════════════════
[OK] INSTALLATION & CONFIGURATION PRÉALABLE
═══════════════════════════════════════════════════════════════════════════════

# 1. Créer compte AWS gratuit
# https://aws.amazon.com/fr/free/
# - 12 mois gratuits (certains services)
# - t2.micro gratuit pendant 12 mois
# - Besoin d'une carte bancaire (sera facturée si vous dépassez)

# 2. Installer AWS CLI (outil en ligne de commande)
# Mac (Homebrew)
brew install awscli

# Linux
sudo apt-get install awscli

# Windows
# Télécharger: https://aws.amazon.com/fr/cli/
# Ou avec pip
pip install awscli

# 3. Configurer AWS CLI
aws configure
# Vous devez fournir:
# AWS Access Key ID: Votre clé (voir dans AWS Console > IAM)
# AWS Secret Access Key: Votre secret (voir dans AWS Console > IAM)
# Default region name: us-east-1 (ou votre région préférée)
# Default output format: json (ou table)

# 4. Vérifier que tout fonctionne
aws sts get-caller-identity
# Affiche vos informations AWS si configuré correctement

# 5. Générer Access Keys si vous n'en avez pas
# Aller dans: AWS Console > IAM > Users > [votre user] > Security credentials
# Créer une nouvelle "Access Key"


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 1 - CRÉER UNE CLÉ SSH (KEY PAIR)
═══════════════════════════════════════════════════════════════════════════════

POURQUOI? Pour pouvoir se connecter à votre instance EC2 sans mot de passe.
C'est comme avoir une clé pour accéder à votre serveur.

# Créer une paire de clés (clé privée + clé publique)
aws ec2 create-key-pair \
  --key-name my-key-pair \
  --query 'KeyMaterial' \
  --output text > my-key-pair.pem

# EXPLICATION DÉTAILLÉE:
# "aws" = Programme AWS CLI
# "ec2" = Service EC2 (Elastic Compute Cloud)
# "create-key-pair" = Créer une paire de clés
# "--key-name my-key-pair" = Donner un nom à la clé (vous pouvez changer "my-key-pair")
# "--query 'KeyMaterial'" = Extraire seulement la clé (pas le reste des infos)
# "--output text" = Afficher en texte simple (pas en JSON)
# "> my-key-pair.pem" = Écrire dans un fichier (> = redirection)
#
# Résumé: "Créer une clé appelée 'my-key-pair', extraire le texte, l'écrire dans un fichier"

# Résultat: Un fichier "my-key-pair.pem" est créé dans votre dossier courant
# Ce fichier contient votre clé privée (À GARDER SECRET!)
# Ne le mettez JAMAIS sur GitHub ou en ligne!
# C'est comme la clé de votre maison - tout le monde pourrait entrer si vous la perdez

# IMPORTANT: Fixer les permissions sur Linux/Mac
chmod 400 my-key-pair.pem

# EXPLICATION DE CHMOD:
# "chmod" = Change Mode (modification des permissions)
# "400" = Signifie:
#   - Propriétaire (vous): 4 = lire (r) seulement
#   - Groupe: 0 = aucune permission
#   - Autres: 0 = aucune permission
#
# En clair: Seul vous pouvez lire ce fichier, personne d'autre
# C'est obligatoire! SSH refusera la clé si les permissions sont mauvaises

# Pour vérifier les permissions:
ls -la my-key-pair.pem
# Résultat: "-r--------" signifie que c'est correct

# Sur Windows: Clic droit > Propriétés > Sécurité
# Enlever tous les droits sauf pour votre utilisateur
# Ou en PowerShell:
# icacls my-key-pair.pem /inheritance:r /grant:r "$($env:USERNAME):(F)"

# Lister vos clés
aws ec2 describe-key-pairs

# Exemple de résultat:
# {
#   "KeyPairs": [
#     {"KeyName": "my-key-pair", "KeyFingerprint": "ab:cd:ef:..."}
#   ]
# }

# Supprimer une clé (attention: irréversible!)
aws ec2 delete-key-pair --key-name my-key-pair

# CONSEIL: Gardez votre fichier .pem en sécurité!
# Créez une sauvegarde à plusieurs endroits


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 2 - CRÉER UN SECURITY GROUP (PARE-FEU)
═══════════════════════════════════════════════════════════════════════════════

POURQUOI? Pour contrôler qui peut se connecter à votre instance.
C'est le pare-feu qui décide: SSH? HTTP? HTTPS? Qui?

CONCEPT: Vous définissez des RÈGLES d'entrée (Ingress)
- SSH (port 22) = se connecter en ligne de commande
- HTTP (port 80) = voir votre site web
- HTTPS (port 443) = voir votre site web en sécurisé
- Etc.

# Créer un security group
aws ec2 create-security-group \
  --group-name my-sg \
  --description "Mon premier security group" \
  --vpc-id vpc-1a2b3c4d

# Résultat: {"GroupId": "sg-0123456789abcdef0"}
# Gardez cet ID, vous en aurez besoin!

# === AJOUTER UNE RÈGLE: SSH depuis votre ordinateur ===

# D'abord: connaître votre IP publique
# Allez sur: https://www.whatismyipaddress.com/
# Ou: curl https://ifconfig.me

# Autoriser SSH SEULEMENT depuis votre IP (SÉCURISÉ!)
aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 22 \
  --cidr 203.0.113.25/32
# Remplacez 203.0.113.25 par votre IP publique

# === AJOUTER UNE RÈGLE: HTTP depuis partout ===

# Si vous voulez un site web public
aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 80 \
  --cidr 0.0.0.0/0
# 0.0.0.0/0 = "Depuis n'importe où sur Internet"

# === AJOUTER UNE RÈGLE: HTTPS depuis partout ===

# Pour un site web sécurisé
aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 443 \
  --cidr 0.0.0.0/0

# Lister vos security groups
aws ec2 describe-security-groups

# Lister les règles d'un security group spécifique
aws ec2 describe-security-groups \
  --group-ids sg-0123456789abcdef0

# Exemple de résultat:
# "IpPermissions": [
#   {"IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "IpRanges": [{"CidrIp": "203.0.113.25/32"}]},
#   {"IpProtocol": "tcp", "FromPort": 80, "ToPort": 80, "IpRanges": [{"CidrIp": "0.0.0.0/0"}]}
# ]

# Supprimer une règle
aws ec2 revoke-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 22 \
  --cidr 0.0.0.0/0

# Supprimer le security group entier
aws ec2 delete-security-group --group-id sg-0123456789abcdef0


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 3 - CHOISIR UNE IMAGE (AMI)
═══════════════════════════════════════════════════════════════════════════════

POURQUOI? L'image = le système d'exploitation de votre instance.
Ubuntu? Amazon Linux? Windows? Vous choisissez!

AMI = "Amazon Machine Image" = une image pré-configurée prête à démarrer

# === IMAGES COURANTES ===
# Ubuntu 22.04 = Populaire, simple, gratuit
# Amazon Linux 2023 = Optimisé pour AWS, gratuit
# Windows Server = Pour Windows (payant)
# CentOS = Gratuit, serveurs robustes

# Trouver l'ID de l'image Ubuntu 22.04
aws ec2 describe-images \
  --owners 099720109477 \
  --filters "Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*" \
  --query 'Images[*].[ImageId,Name,CreationDate]' \
  --output table

# Résultat: Une liste des images Ubuntu disponibles
# Prenez le dernier ID (la plus récente)
# Exemple: ami-0c55b159cbfafe1f0

# Trouver l'ID de l'image Amazon Linux 2023
aws ec2 describe-images \
  --owners amazon \
  --filters "Name=name,Values=al2023-ami-2023*-x86_64" \
  --query 'Images | sort_by(@, &CreationDate) | [-1].[ImageId,Name]'

# CONSEIL POUR DÉBUTANTS: Utilisez Ubuntu 22.04
# C'est le plus facile pour apprendre


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 4 - CHOISIR UN TYPE D'INSTANCE
═══════════════════════════════════════════════════════════════════════════════

TYPE D'INSTANCE = Puissance de votre ordinateur virtuel

C'est comme choisir:
- t2.micro = Petit bureau (gratuit 12 mois, 1 vCPU, 1 GB RAM)
- t2.small = Bureau normal (1 vCPU, 2 GB RAM)
- t2.medium = Bon ordinateur (2 vCPU, 4 GB RAM)
- m5.large = Serveur puissant (2 vCPU, 8 GB RAM)
- c5.large = Pour calculs lourds (2 vCPU, 4 GB RAM)

POUR DÉBUTANTS: t2.micro (gratuit pendant 12 mois!)

# Voir les types disponibles
aws ec2 describe-instance-types \
  --filters "Name=instance-type,Values=t2.*" \
  --query 'InstanceTypes[*].[InstanceType,VCpuInfo.DefaultVCpus,MemoryInfo.SizeInMiB]' \
  --output table

# Résultat: Liste des types t2 avec vCPU et RAM


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 5 - LANCER VOTRE PREMIÈRE INSTANCE
═══════════════════════════════════════════════════════════════════════════════

Vous avez maintenant tout ce qu'il faut:
1. Une clé SSH (my-key-pair.pem)
2. Un security group (sg-0123456789abcdef0)
3. Une image (ami-0c55b159cbfafe1f0)
4. Un type d'instance (t2.micro)

LANÇONS!

# Commande pour lancer une instance
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t2.micro \
  --key-name my-key-pair \
  --security-group-ids sg-0123456789abcdef0 \
  --count 1 \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=MyFirstServer}]'

# Explication:
# --image-id = L'OS que vous avez choisi
# --instance-type = t2.micro (gratuit)
# --key-name = La clé SSH que vous avez créée
# --security-group-ids = Le pare-feu que vous avez configuré
# --count = 1 instance
# --tag-specifications = Nommer votre instance "MyFirstServer"

# Résultat: Vous voyez les détails de votre instance
# Important: Notez l'InstanceId = i-1234567890abcdef0
# Vous en aurez besoin pour gérer votre instance!

# Résultat: Vous voyez aussi PublicIpAddress = 203.0.113.45
# C'est l'IP pour accéder à votre instance par SSH


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 6 - SE CONNECTER À VOTRE INSTANCE
═══════════════════════════════════════════════════════════════════════════════

OBJECTIF: Vous connecter à votre serveur comme si vous êtiez dedans

# Sur Linux/Mac, ouvrir le terminal et:

ssh -i my-key-pair.pem ubuntu@203.0.113.45

# Explication:
# ssh = "Secure Shell" (connexion sécurisée)
# -i my-key-pair.pem = Utiliser votre clé privée
# ubuntu = Nom d'utilisateur (Ubuntu par défaut)
# 203.0.113.45 = IP publique de votre instance

# Premier message:
# "Are you sure you want to continue connecting? (yes/no)"
# Répondez: yes

# Vous êtes connecté! Vous êtes maintenant DANS votre serveur
# Vous pouvez taper des commandes comme sur votre ordinateur

# Exemples:
pwd                 # Voir le dossier actuel
ls                  # Lister fichiers
uname -a            # Info du système
df -h               # Espace disque


# === SUR WINDOWS ===

# Méthode 1: Avec PuTTY (GUI)
# 1. Télécharger PuTTY et PuTTYgen
# 2. Ouvrir PuTTYgen
# 3. Charger my-key-pair.pem
# 4. Exporter en .ppk
# 5. Ouvrir PuTTY
# 6. Hostname: ubuntu@203.0.113.45
# 7. SSH > Auth > .ppk
# 8. Connect

# Méthode 2: Avec Windows Terminal/PowerShell
# Si vous avez SSH d'installé (Windows 10+)
ssh -i my-key-pair.pem ubuntu@203.0.113.45

# Méthode 3: Avec Git Bash
# Git Bash inclut SSH
ssh -i my-key-pair.pem ubuntu@203.0.113.45

# Pour quitter votre session SSH:
exit


═══════════════════════════════════════════════════════════════════════════════
[OK] ÉTAPE 7 - GÉRER VOTRE INSTANCE
═══════════════════════════════════════════════════════════════════════════════

Maintenant que votre instance est lancée, vous pouvez:

# Lister TOUTES vos instances
aws ec2 describe-instances

# Résultat: Beaucoup d'informations (JSON)

# Lister en format lisible
aws ec2 describe-instances \
  --query 'Reservations[*].Instances[*].[InstanceId,State.Name,InstanceType,PublicIpAddress,Tags[?Key==`Name`].Value|[0]]' \
  --output table

# Résultat:
# | InstanceId | State | InstanceType | PublicIpAddress | Name |
# | i-123456 | running | t2.micro | 203.0.113.45 | MyFirstServer |

# === ARRÊTER L'INSTANCE ===
# (Vous continuez à payer, mais elle est arrêtée)
aws ec2 stop-instances --instance-ids i-1234567890abcdef0

# === DÉMARRER L'INSTANCE ===
aws ec2 start-instances --instance-ids i-1234567890abcdef0

# === REDÉMARRER L'INSTANCE ===
aws ec2 reboot-instances --instance-ids i-1234567890abcdef0

# === TERMINER L'INSTANCE ===
# (SUPPRESSION DÉFINITIVE! Vous arrêtez de payer)
# Attention: C'est irréversible!
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

# === AJOUTER DES TAGS (ÉTIQUETTES) ===
# Pour mieux identifier vos instances
aws ec2 create-tags \
  --resources i-1234567890abcdef0 \
  --tags Key=Environment,Value=Development Key=Team,Value=Backend

# === OBTENIR L'IP PUBLIQUE ===
aws ec2 describe-instances \
  --instance-ids i-1234567890abcdef0 \
  --query 'Reservations[0].Instances[0].PublicIpAddress' \
  --output text

# Résultat: 203.0.113.45


═══════════════════════════════════════════════════════════════════════════════
[OK] BONUS - ELASTIC IP (IP FIXE)
═══════════════════════════════════════════════════════════════════════════════

PROBLÈME: Si vous arrêtez puis redémarrez votre instance,
son adresse IP publique change!

SOLUTION: Utiliser une Elastic IP (IP fixe)

# Allouer une Elastic IP
aws ec2 allocate-address --domain vpc

# Résultat: 
# {
#   "AllocationId": "eipalloc-12345678",
#   "PublicIp": "203.0.113.100"
# }

# Associer l'Elastic IP à votre instance
aws ec2 associate-address \
  --instance-id i-1234567890abcdef0 \
  --allocation-id eipalloc-12345678

# Maintenant, votre instance a une IP fixe!
# Même si vous l'arrêtez et la redémarrez,
# l'IP reste la même

# Lister vos Elastic IPs
aws ec2 describe-addresses

# Dissocier
aws ec2 disassociate-address --association-id eipassoc-12345678

# Libérer (vous ne payez plus pour cette IP)
aws ec2 release-address --allocation-id eipalloc-12345678


═══════════════════════════════════════════════════════════════════════════════
[OK] BONUS - USER DATA (SCRIPT AU DÉMARRAGE)
═══════════════════════════════════════════════════════════════════════════════

USER DATA = Un script qui s'exécute automatiquement au démarrage

UTILITÉ: Installer Apache, un serveur web, mettre à jour le système, etc.

# Créer un fichier userdata.sh
# userdata.sh
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd
echo "<h1>Hello from EC2!</h1>" > /var/www/html/index.html

# Explication:
# yum update -y = Mettre à jour le système
# yum install -y httpd = Installer Apache (serveur web)
# systemctl start httpd = Démarrer Apache
# systemctl enable httpd = Apache redémarre automatiquement
# echo = Créer une page HTML

# Lancer instance AVEC user data
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t2.micro \
  --key-name my-key-pair \
  --security-group-ids sg-0123456789abcdef0 \
  --user-data file://userdata.sh

# Attendez quelques secondes, puis accédez à votre site:
# http://203.0.113.45/

# Vous devez voir: "Hello from EC2!"

# CONSEIL: Le user data s'exécute une seule fois au PREMIER démarrage


═══════════════════════════════════════════════════════════════════════════════
[OK] BONUS - VOLUMES EBS (STOCKAGE SUPPLÉMENTAIRE)
═══════════════════════════════════════════════════════════════════════════════

EBS = Disque dur virtuel pour votre instance

PAR DÉFAUT: Votre instance a un disque de 8 GB

# Créer un volume EBS supplémentaire
aws ec2 create-volume \
  --availability-zone us-east-1a \
  --size 20 \
  --volume-type gp3 \
  --tag-specifications 'ResourceType=volume,Tags=[{Key=Name,Value=MyExtraStorage}]'

# Résultat: {"VolumeId": "vol-1234567890abcdef0"}

# Attacher le volume à votre instance
aws ec2 attach-volume \
  --volume-id vol-1234567890abcdef0 \
  --instance-id i-1234567890abcdef0 \
  --device /dev/sdf

# Lister vos volumes
aws ec2 describe-volumes

# Créer un snapshot (sauvegarde) du volume
aws ec2 create-snapshot \
  --volume-id vol-1234567890abcdef0 \
  --description "Sauvegarde de mon stockage"

# Lister snapshots
aws ec2 describe-snapshots --owner-ids self

# EXPLICATION:
# "describe-snapshots" = Lister les snapshots
# "--owner-ids self" = Seulement vos snapshots (pas ceux d'autres gens)
#
# "self" = AWS Magic word pour "mes ressources"
#
# Résultat:
# {
#   "Snapshots": [
#     {
#       "SnapshotId": "snap-1234567890abcdef0",
#       "State": "completed",
#       "VolumeSize": 20,
#       "Description": "My snapshot"
#     }
#   ]
# }

# Détacher le volume
aws ec2 detach-volume --volume-id vol-1234567890abcdef0

# Supprimer le volume
aws ec2 delete-volume --volume-id vol-1234567890abcdef0


═══════════════════════════════════════════════════════════════════════════════
[OK] BONNES PRATIQUES POUR DÉBUTER
═══════════════════════════════════════════════════════════════════════════════

# 1. TOUJOURS utiliser des Security Groups restrictifs
# Ne jamais ouvrir SSH (port 22) au monde entier (0.0.0.0/0)
# Utilisez votre IP personnelle

# 2. Garder votre clé SSH en sécurité
# Sauvegardez my-key-pair.pem à plusieurs endroits
# Ne la mettez JAMAIS sur GitHub
# chmod 400 my-key-pair.pem (Linux/Mac)

# 3. Utiliser Elastic IP si vous avez besoin d'une IP fixe
# Sinon, l'IP change à chaque redémarrage

# 4. Terminer les instances quand vous ne les utilisez pas
# Vous payez par heure! Arrêter != Terminer
# Terminer = Suppression définitive (pas de facturation)

# 5. Utiliser des Tags pour identifier vos instances
# Key=Environment,Value=Development
# Key=Project,Value=MyApp
# Key=Owner,Value=YourName

# 6. Documenter vos configurations
# Noteque vous avez utilisé quel AMI, quel type d'instance, etc.

# 7. Créer des snapshots régulièrement
# Pour les volumes EBS importants
# C'est votre assurance contre la perte de données

# 8. Vérifier votre facturation régulièrement
# AWS Console > Billing
# Assurez-vous que vous ne dépassez pas le free tier

# 9. Utiliser CloudWatch pour surveiller
# CPU, réseau, disque, etc.

# 10. Automatiser avec des scripts
# User data pour les configurations
# AWS CLI dans des scripts bash


═══════════════════════════════════════════════════════════════════════════════
[OK] DÉPANNAGE COURANT
═══════════════════════════════════════════════════════════════════════════════

# === PROBLÈME: Impossible de se connecter en SSH ===

# 1. Vérifier que votre clé a les bons droits
chmod 400 my-key-pair.pem

# 2. Vérifier que votre Security Group autorise SSH (port 22)
aws ec2 describe-security-groups --group-ids sg-0123456789abcdef0

# 3. Attendre que l'instance soit complètement lancée
# Cela peut prendre quelques minutes

# 4. Vérifier l'IP publique
aws ec2 describe-instances --instance-ids i-1234567890abcdef0

# 5. Essayer avec -v pour voir les détails
ssh -v -i my-key-pair.pem ubuntu@203.0.113.45

# === PROBLÈME: "Permission denied" avec la clé SSH ===

# Sur Linux/Mac:
chmod 400 my-key-pair.pem

# Sur Windows (PuTTY):
# PuTTYgen > Load > my-key-pair.pem > Save private key as .ppk

# === PROBLÈME: Mon instance s'arrête toute seule ===

# 1. Vérifier les logs
# SSH dans l'instance et regarder les logs du système

# 2. Vérifier les alarmes CloudWatch
# Peut-être que l'instance n'a pas assez de mémoire

# 3. Vérifier que vous n'avez pas terminé l'instance
aws ec2 describe-instances --instance-ids i-1234567890abcdef0

# === PROBLÈME: Je suis facturé mais mon instance ne tourne pas ===

# Vérifier vos instances ARRÊTÉES
aws ec2 describe-instances \
  --filters "Name=instance-state-name,Values=stopped"

# Terminer les instances que vous ne voulez pas garder
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0


═══════════════════════════════════════════════════════════════════════════════
[OK] CAS D'USAGE COURANTS
═══════════════════════════════════════════════════════════════════════════════

# === CAS 1: Héberger un site web simple ===

# 1. Lancer instance t2.micro
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t2.micro \
  --key-name my-key-pair \
  --security-group-ids sg-0123456789abcdef0 \
  --user-data file://install-apache.sh

# install-apache.sh:
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd

# 2. Associer une Elastic IP
aws ec2 allocate-address --domain vpc
aws ec2 associate-address --instance-id i-xxx --allocation-id eipalloc-xxx

# 3. Accéder au site: http://203.0.113.45/

# === CAS 2: Serveur de développement ===

# 1. t2.micro ou t2.small
# 2. SSH depuis votre IP seulement
# 3. Installer votre stack (Python, Node.js, PostgreSQL, etc.)
# 4. Lancer votre application

# === CAS 3: Base de données ===

# 1. t2.small ou plus (base de données = gourmand en RAM)
# 2. Ajouter un volume EBS supplémentaire pour les données
# 3. Security Group: seulement depuis vos applications
# 4. Créer des snapshots réguliers

# === CAS 4: Load balancer ===

# 1. Lancer plusieurs instances
# 2. Utiliser AWS ELB pour distribuer le trafic
# 3. Chaque instance a sa propre Elastic IP
# 4. L'ELB balance le trafic entre elles


═══════════════════════════════════════════════════════════════════════════════
[OK] TYPES D'INSTANCES POPULAIRES
═══════════════════════════════════════════════════════════════════════════════

GRATUIT 12 MOIS:
- t2.micro: 1 vCPU, 1 GB RAM (parfait pour débuter)

GÉNÉRALISTES:
- t2.small: 1 vCPU, 2 GB RAM
- t2.medium: 2 vCPU, 4 GB RAM
- t3.small: 2 vCPU, 2 GB RAM (plus récent, ~20% plus rapide)
- t3.medium: 2 vCPU, 4 GB RAM

PERFORMANCE GÉNÉRALE:
- m5.large: 2 vCPU, 8 GB RAM
- m5.xlarge: 4 vCPU, 16 GB RAM

OPTIMISÉ CALCUL (CPU lourd):
- c5.large: 2 vCPU, 4 GB RAM
- c5.xlarge: 4 vCPU, 8 GB RAM

OPTIMISÉ MÉMOIRE (Bases de données):
- r5.large: 2 vCPU, 16 GB RAM
- r5.xlarge: 4 vCPU, 32 GB RAM

POUR DÉBUTER: t2.micro (gratuit) ou t2.small (très abordable)


═══════════════════════════════════════════════════════════════════════════════
[OK] FACTURE AWS: CE QUE VOUS ALLEZ PAYER
═══════════════════════════════════════════════════════════════════════════════

GRATUIT 12 MOIS (Si vous respectez le free tier):
- t2.micro: 730 heures/mois = 1 instance gratuite
- 30 GB EBS gp2
- 100 GB sortie données gratuite

APRÈS 12 MOIS OU SI VOUS DÉPASSEZ:
- t2.micro: ~$0.01/heure (~$7/mois si 24h/24)
- t2.small: ~$0.02/heure (~$15/mois si 24h/24)
- t2.medium: ~$0.04/heure (~$30/mois si 24h/24)
- EBS gp3: ~$0.10/GB/mois
- Élastic IP (si inutilisée): $0.005/heure

CONSEIL: Vérifiez votre facturation mensuelle!
AWS Console > Billing Dashboard


═══════════════════════════════════════════════════════════════════════════════
[OK] WORKFLOW COMPLET POUR DÉBUTANT
═══════════════════════════════════════════════════════════════════════════════

ÉTAPE 1: Préparer votre machine locale
# Installer AWS CLI
pip install awscli

# Configurer
aws configure

# Vérifier
aws sts get-caller-identity


ÉTAPE 2: Créer une clé SSH
aws ec2 create-key-pair \
  --key-name my-first-key \
  --query 'KeyMaterial' \
  --output text > my-first-key.pem

chmod 400 my-first-key.pem


ÉTAPE 3: Créer un Security Group
aws ec2 create-security-group \
  --group-name my-first-sg \
  --description "Mon premier security group"

# Résultat: sg-0123456789abcdef0


ÉTAPE 4: Autoriser SSH depuis votre IP
# Trouvez votre IP: https://www.whatismyipaddress.com/
# Supposons: 192.168.1.100

aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 22 \
  --cidr 192.168.1.100/32

# EXPLICATION:
# Vous venez de dire à AWS:
# "Autoriser les connexions SSH (port 22) SEULEMENT depuis ma machine"
# Les hackers ne peuvent pas se connecter depuis ailleurs


ÉTAPE 5: Trouver une image Ubuntu
aws ec2 describe-images \
  --owners 099720109477 \
  --filters "Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*" \
  --query 'Images | sort_by(@, &CreationDate) | [-1].ImageId' \
  --output text

# Résultat: ami-0c55b159cbfafe1f0


ÉTAPE 6: Lancer votre instance
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t2.micro \
  --key-name my-first-key \
  --security-group-ids sg-0123456789abcdef0 \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=MyFirstInstance}]'

# Attendez 30-60 secondes


ÉTAPE 7: Obtenir l'IP publique
aws ec2 describe-instances \
  --filters "Name=tag:Name,Values=MyFirstInstance" \
  --query 'Reservations[0].Instances[0].PublicIpAddress' \
  --output text

# Résultat: 203.0.113.45


ÉTAPE 8: Se connecter en SSH
ssh -i my-first-key.pem ubuntu@203.0.113.45

# Bienvenue sur votre serveur!


ÉTAPE 9: Faire quelque chose
# Une fois connecté:
sudo apt update
sudo apt upgrade -y
sudo apt install -y git python3-pip


ÉTAPE 10: Terminer quand vous avez fini
# Quitter SSH
exit

# Terminer l'instance
aws ec2 terminate-instances \
  --instance-ids i-1234567890abcdef0


═══════════════════════════════════════════════════════════════════════════════
[OK] RESSOURCES & DOCUMENTATION
═══════════════════════════════════════════════════════════════════════════════

DOCUMENTATION OFFICIELLE:
- AWS EC2 Documentation: https://docs.aws.amazon.com/ec2/
- AWS CLI Reference: https://docs.aws.amazon.com/cli/latest/
- Free Tier Details: https://aws.amazon.com/fr/free/

TUTORIELS UTILES:
- AWS Getting Started: https://aws.amazon.com/fr/getting-started/
- EC2 User Guide: https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/

OUTILS:
- AWS Console (Web): https://console.aws.amazon.com/
- AWS CLI: https://aws.amazon.com/fr/cli/
- PuTTY (Windows): https://www.putty.org/

SÉCURITÉ:
- Never commit your .pem file to Git!
- Use .gitignore: echo "*.pem" >> .gitignore
- Store backups securely (not on GitHub!)
- Use IAM users for CLI access (not root)


═══════════════════════════════════════════════════════════════════════════════
[OK] COMPARAISON AWS EC2 vs AUTRES
═══════════════════════════════════════════════════════════════════════════════

EC2 vs Heroku:
- EC2: Plus cher, mais plus de contrôle, plus flexible
- Heroku: Plus cher pour petit usage, mais plus simple

EC2 vs DigitalOcean:
- EC2: Cher pour débutants, mais plus de services
- DigitalOcean: Plus simple, moins cher, moins de services

EC2 vs Linode:
- EC2: Complexe mais très scalable
- Linode: Intermédiaire, bon rapport qualité/prix

Pour débuter: DigitalOcean ou Linode
Pour production d'entreprise: AWS EC2


═══════════════════════════════════════════════════════════════════════════════
[OK] ERREURS COURANTES À ÉVITER
═══════════════════════════════════════════════════════════════════════════════

ERREUR 1: Ouvrir SSH au monde entier (0.0.0.0/0)
[X] MAUVAIS: --cidr 0.0.0.0/0
[OK] BON: --cidr 192.168.1.100/32 (votre IP)
Risque: Hackers essaient de se connecter

ERREUR 2: Perdre son fichier .pem
[X] Impossible de se connecter à l'instance!
[OK] Sauvegardez-le à plusieurs endroits

ERREUR 3: Oublier de terminer une instance
[X] Vous payez même si vous n'l'utilisez pas
[OK] Vérifiez votre facturation chaque mois

ERREUR 4: Ne pas faire de snapshots
[X] Si le disque échoue, vous perdez vos données
[OK] Créez des snapshots réguliers

ERREUR 5: Utiliser un mot de passe faible
[X] Avec root ou sudo sans SSH key
[OK] Utilisez TOUJOURS SSH key

ERREUR 6: Ne pas configurer de Security Group
[X] Ports inutiles ouverts = sécurité faible
[OK] Ouvrez seulement les ports nécessaires

ERREUR 7: Utiliser une région trop loin
[X] Latence élevée pour vos utilisateurs
[OK] Choisissez une région proche de vos utilisateurs

ERREUR 8: Ne pas faire de mise à jour de sécurité
[X] Vulnerabilités exploitables
[OK] sudo apt update && sudo apt upgrade -y régulièrement