AWS - Intermédiaire : VPC, RDS, Lambda et CloudFormation

VPC : 10.0.0.0/16
├── Sous-réseau public  10.0.1.0/24  (az-a)  ← Accessible depuis Internet
│   └── Bastion, Load Balancer
├── Sous-réseau public  10.0.2.0/24  (az-b)
│   └── Bastion, Load Balancer
├── Sous-réseau privé   10.0.10.0/24 (az-a)  ← Pas d'accès Internet direct
│   └── EC2, ECS, Lambda
└── Sous-réseau privé   10.0.20.0/24 (az-b)
    └── EC2, ECS, Lambda

# 1. Créer le VPC
VPC_ID=$(aws ec2 create-vpc \
  --cidr-block 10.0.0.0/16 \
  --query 'Vpc.VpcId' --output text)
aws ec2 create-tags --resources $VPC_ID --tags Key=Name,Value=mon-vpc

# 2. Créer les sous-réseaux
SUBNET_PUB=$(aws ec2 create-subnet \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.1.0/24 \
  --availability-zone eu-west-3a \
  --query 'Subnet.SubnetId' --output text)

SUBNET_PRIV=$(aws ec2 create-subnet \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.10.0/24 \
  --availability-zone eu-west-3a \
  --query 'Subnet.SubnetId' --output text)

# 3. Créer et attacher l'Internet Gateway
IGW_ID=$(aws ec2 create-internet-gateway --query 'InternetGateway.InternetGatewayId' --output text)
aws ec2 attach-internet-gateway --internet-gateway-id $IGW_ID --vpc-id $VPC_ID

# 4. Configurer la route table publique
RTB_ID=$(aws ec2 create-route-table --vpc-id $VPC_ID --query 'RouteTable.RouteTableId' --output text)
aws ec2 create-route --route-table-id $RTB_ID --destination-cidr-block 0.0.0.0/0 --gateway-id $IGW_ID
aws ec2 associate-route-table --route-table-id $RTB_ID --subnet-id $SUBNET_PUB

# Créer un subnet group (obligatoire pour RDS)
aws rds create-db-subnet-group \
  --db-subnet-group-name mon-subnet-group \
  --db-subnet-group-description "Subnet group pour RDS" \
  --subnet-ids subnet-xxxx subnet-yyyy

# Lancer une instance RDS PostgreSQL
aws rds create-db-instance \
  --db-instance-identifier ma-base \
  --db-instance-class db.t3.micro \
  --engine postgres \
  --engine-version 15.4 \
  --master-username admin \
  --master-user-password MonMotDePasse123! \
  --allocated-storage 20 \
  --db-subnet-group-name mon-subnet-group \
  --vpc-security-group-ids sg-xxxx \
  --multi-az \
  --backup-retention-period 7 \
  --no-publicly-accessible

# Suivre la création (prend ~5 minutes)
aws rds describe-db-instances \
  --db-instance-identifier ma-base \
  --query 'DBInstances[0].DBInstanceStatus'

# Créer le code de la fonction (fichier lambda_function.py)
cat > lambda_function.py << 'EOF'
import json

def lambda_handler(event, context):
    """
    Fonction Lambda simple : retourne un message avec les données reçues.
    event : dict contenant les données de l'événement déclencheur
    context : informations sur l'exécution (timeout restant, etc.)
    """
    name = event.get('name', 'Monde')
    return {
        'statusCode': 200,
        'body': json.dumps({'message': f'Bonjour {name} depuis Lambda!'})
    }
EOF

# Zipper le code
zip function.zip lambda_function.py

# Créer la fonction
aws lambda create-function \
  --function-name ma-fonction \
  --runtime python3.12 \
  --role arn:aws:iam::ACCOUNT_ID:role/lambda-role \
  --handler lambda_function.lambda_handler \
  --zip-file fileb://function.zip \
  --timeout 30 \
  --memory-size 128

# Invoquer la fonction
aws lambda invoke \
  --function-name ma-fonction \
  --payload '{"name": "Alice"}' \
  --cli-binary-format raw-in-base64-out \
  output.json
cat output.json
# {"statusCode": 200, "body": "{\"message\": \"Bonjour Alice depuis Lambda!\"}"}

AWSTemplateFormatVersion: '2010-09-09'
Description: "Stack exemple : EC2 + Security Group"

# Variables d'entrée
Parameters:
  InstanceType:
    Type: String
    Default: t3.micro
    AllowedValues: [t3.micro, t3.small, t3.medium]
    Description: "Type d'instance EC2"

  KeyPairName:
    Type: AWS::EC2::KeyPair::KeyName
    Description: "Paire de clés SSH"

# Ressources à créer
Resources:
  WebServerSG:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: "Security Group serveur web"
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 443
          ToPort: 443
          CidrIp: 0.0.0.0/0

  WebServer:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType: !Ref InstanceType          # Référence au paramètre
      KeyName: !Ref KeyPairName
      ImageId: ami-0c02fb55956c7d316
      SecurityGroupIds:
        - !Ref WebServerSG                      # Référence à la ressource ci-dessus
      UserData:
        Fn::Base64: |
          #!/bin/bash
          yum update -y
          yum install -y httpd
          systemctl start httpd
          systemctl enable httpd

# Valeurs exportées
Outputs:
  PublicIP:
    Description: "Adresse IP publique du serveur"
    Value: !GetAtt WebServer.PublicIp           # Attribut de la ressource
    Export:
      Name: WebServerPublicIP

# Valider le template avant déploiement
aws cloudformation validate-template --template-body file://stack.yaml

# Créer la stack
aws cloudformation create-stack \
  --stack-name mon-stack \
  --template-body file://stack.yaml \
  --parameters \
    ParameterKey=InstanceType,ParameterValue=t3.micro \
    ParameterKey=KeyPairName,ParameterValue=ma-cle \
  --capabilities CAPABILITY_IAM

# Suivre la création
aws cloudformation describe-stacks \
  --stack-name mon-stack \
  --query 'Stacks[0].StackStatus'

# Mettre à jour une stack
aws cloudformation update-stack \
  --stack-name mon-stack \
  --template-body file://stack.yaml

# Créer un change set (voir les changements avant d'appliquer)
aws cloudformation create-change-set \
  --stack-name mon-stack \
  --change-set-name mes-modifications \
  --template-body file://stack-v2.yaml

# Supprimer la stack (et toutes ses ressources)
aws cloudformation delete-stack --stack-name mon-stack

Internet → ALB → Target Group → EC2 instances
                              ├── i-aaa (zone a)
                              ├── i-bbb (zone b)
                              └── i-ccc (zone a)

# Créer un Launch Template (modèle de configuration d'instance)
aws ec2 create-launch-template \
  --launch-template-name mon-template \
  --launch-template-data '{
    "ImageId": "ami-0c02fb55956c7d316",
    "InstanceType": "t3.micro",
    "KeyName": "ma-cle",
    "SecurityGroupIds": ["sg-xxxx"]
  }'

# Créer l'Auto Scaling Group
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name mon-asg \
  --launch-template LaunchTemplateName=mon-template,Version='$Latest' \
  --min-size 2 \
  --max-size 6 \
  --desired-capacity 2 \
  --availability-zones eu-west-3a eu-west-3b \
  --target-group-arns arn:aws:elasticloadbalancing:...

# Créer une politique de scaling (ex: ajouter une instance si CPU > 70%)
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name mon-asg \
  --policy-name cpu-scale-up \
  --policy-type TargetTrackingScaling \
  --target-tracking-configuration '{
    "PredefinedMetricSpecification": {"PredefinedMetricType": "ASGAverageCPUUtilization"},
    "TargetValue": 70.0
  }'