Guide Complet : Réduire l'Empreinte Carbone du Cloud

1

Impact = Nombre de services × Intensité par service × Intensité carbone de l'énergie

1

PUE = Énergie totale du data center / Énergie des équipements IT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Exemple d'export via AWS CLI
import boto3
import json

ce = boto3.client('ce')

response = ce.get_cost_and_usage(
    TimePeriod={
        'Start': '2024-01-01',
        'End': '2024-12-31'
    },
    Granularity='MONTHLY',
    Metrics=['UnblendedCost'],
    GroupBy=[
        {'Type': 'DIMENSION', 'Key': 'SERVICE'},
        {'Type': 'DIMENSION', 'Key': 'REGION'}
    ]
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- Requête BigQuery pour analyser les émissions
SELECT
  usage_month,
  service.description as service,
  location.location as region,
  carbon_footprint_total_kgCO2e.scope1,
  carbon_footprint_total_kgCO2e.scope2,
  carbon_footprint_total_kgCO2e.scope3
FROM `project.carbon_footprint.carbon_footprint_export`
WHERE usage_month BETWEEN '2024-01' AND '2024-12'
ORDER BY carbon_footprint_total_kgCO2e.scope2 DESC

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Cloner le repository
git clone https://github.com/cloud-carbon-footprint/cloud-carbon-footprint.git
cd cloud-carbon-footprint

# Installer les dépendances
yarn install

# Configurer les credentials (voir documentation)
cp packages/api/.env.template packages/api/.env
# Éditer .env avec vos credentials cloud

# Lancer l'application
yarn start

1
2
3
4
5
6
7
8

# Variables d'environnement requises
AWS_TARGET_ACCOUNT_ROLE_NAME=CCFRole
AWS_ATHENA_DB_NAME=ccf_database
AWS_ATHENA_DB_TABLE=ccf_table
AWS_ATHENA_REGION=eu-west-1
AWS_ATHENA_QUERY_RESULT_LOCATION=s3://ccf-results/
AWS_BILLING_ACCOUNT_ID=123456789012
AWS_BILLING_ACCOUNT_NAME=main-account

1
2
3
4
5
6

Émissions = Utilisation × Facteur d'émission × Coefficient PUE

Où :
- Utilisation = heures × puissance (vCPU, mémoire, stockage)
- Facteur d'émission = gCO2e/kWh selon la région
- Coefficient PUE = overhead du data center

1

Émissions = Dépenses cloud (€) × Facteur d'émission sectoriel (kgCO2e/€)

1

Émissions = Heures d'utilisation × Puissance moyenne × PUE × Facteur d'émission

1

Émissions = Volume (TB) × Puissance par TB × Heures × PUE × Facteur d'émission

1

Émissions = Volume transféré (TB) × Énergie par TB × Facteur d'émission

1

Émissions scope 3 = Émissions fabrication × (Utilisation / Durée de vie totale)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Configuration dashboard Cloud Carbon
panels:
  - title: "Émissions mensuelles par service"
    type: timeseries
    datasource: prometheus
    targets:
      - expr: sum(cloud_carbon_emissions_kg) by (service)

  - title: "Top 10 ressources émettrices"
    type: table
    datasource: prometheus
    targets:
      - expr: topk(10, cloud_carbon_emissions_kg)

  - title: "Utilisation CPU moyenne"
    type: gauge
    datasource: prometheus
    targets:
      - expr: avg(cpu_utilization_percent)
    thresholds:
      - value: 30
        color: red
      - value: 50
        color: yellow
      - value: 70
        color: green

1
2

Plus efficient ←——————————————————→ Moins efficient
Serverless > Containers > VMs > Bare metal

1
2
3
4
5
6

# Arrêt automatique des VMs de dev le soir
# AWS Instance Scheduler
aws scheduler create-schedule \
  --name "dev-instances-stop" \
  --schedule-expression "cron(0 19 ? * MON-FRI *)" \
  --target '{"Arn": "arn:aws:lambda:...", "RoleArn": "..."}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Resource requests et limits pour un pod
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: app
    resources:
      requests:
        cpu: "100m"      # Minimum garanti
        memory: "128Mi"
      limits:
        cpu: "500m"      # Maximum autorisé
        memory: "512Mi"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Function optimisée : mémoire minimale, exécution rapide
import json

def handler(event, context):
    # Éviter les imports lourds au runtime
    # Traitement minimal
    result = process(event)

    return {
        'statusCode': 200,
        'body': json.dumps(result),
        'headers': {
            'Content-Type': 'application/json',
            # Cache pour réduire les invocations
            'Cache-Control': 'max-age=300'
        }
    }

1
2
3
4
5
6
7
8
9

Overhead microservices = N services × (Sidecar + Baseline + Réseau)

Exemple :
- 50 microservices
- Sidecar Envoy : 100MB RAM, 0.1 CPU
- Baseline par service : 256MB RAM
- Réseau inter-services : +30% latence

Overhead total : 50 × (100MB + 256MB) = 17.8 GB RAM juste pour l'overhead

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Monolithe modulaire
┌─────────────────────────────────────┐
│  ┌─────────┐ ┌─────────┐ ┌────────┐│
│  │ Module  │ │ Module  │ │ Module ││
│  │   A     │ │   B     │ │   C    ││
│  └────┬────┘ └────┬────┘ └───┬────┘│
│       │           │          │     │
│  ┌────┴───────────┴──────────┴────┐│
│  │        Shared Infrastructure    ││
│  └─────────────────────────────────┘│
└─────────────────────────────────────┘
        Un seul déploiement
        Communication in-process

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Worker edge pour cache et transformation
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const cache = caches.default
  let response = await cache.match(request)

  if (!response) {
    response = await fetch(request)
    // Cacher à l'edge pour 1 heure
    response = new Response(response.body, response)
    response.headers.set('Cache-Control', 'max-age=3600')
    event.waitUntil(cache.put(request, response.clone()))
  }

  return response
}

1
2
3
4
5

Client → Serveur : "Nouvelles données ?" (toutes les 5s)
Serveur → Client : "Non"
Client → Serveur : "Nouvelles données ?" (toutes les 5s)
Serveur → Client : "Non"
... (99% de requêtes inutiles)

1
2
3

Client s'abonne aux événements
...
Serveur → Client : "Nouvelle donnée !" (quand elle existe)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Infrastructure as Code (SAM)
EventRule:
  Type: AWS::Events::Rule
  Properties:
    EventPattern:
      source:
        - "my.application"
      detail-type:
        - "OrderCreated"
    Targets:
      - Arn: !GetAtt ProcessOrderFunction.Arn
        Id: "ProcessOrder"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Exemple : batch processing carbon-aware
from electricity_maps import get_carbon_intensity

def should_run_batch():
    intensity = get_carbon_intensity(region='FR')
    threshold = 100  # gCO2/kWh

    if intensity < threshold:
        return True

    # Reporter si possible
    if can_delay(hours=4):
        return False

    # Exécuter quand même si urgent
    return is_urgent()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Exemple : qualité vidéo adaptative
def get_video_quality(user_region):
    intensity = get_carbon_intensity(user_region)

    if intensity < 50:
        return '4K'
    elif intensity < 200:
        return '1080p'
    else:
        return '720p'  # Mode éco automatique

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Kubernetes : scheduling carbon-aware
apiVersion: v1
kind: Pod
metadata:
  name: batch-job
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: carbon-intensity
            operator: Lt
            values:
            - "100"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import boto3
from datetime import datetime, timedelta

cloudwatch = boto3.client('cloudwatch')

def analyze_instance(instance_id):
    end_time = datetime.utcnow()
    start_time = end_time - timedelta(days=14)

    # CPU utilization
    cpu_stats = cloudwatch.get_metric_statistics(
        Namespace='AWS/EC2',
        MetricName='CPUUtilization',
        Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
        StartTime=start_time,
        EndTime=end_time,
        Period=3600,
        Statistics=['Average', 'Maximum']
    )

    avg_cpu = sum(d['Average'] for d in cpu_stats['Datapoints']) / len(cpu_stats['Datapoints'])
    max_cpu = max(d['Maximum'] for d in cpu_stats['Datapoints'])

    return {
        'instance_id': instance_id,
        'avg_cpu': avg_cpu,
        'max_cpu': max_cpu,
        'recommendation': get_recommendation(avg_cpu, max_cpu)
    }

def get_recommendation(avg_cpu, max_cpu):
    if avg_cpu < 10 and max_cpu < 30:
        return 'DOWNSIZE_AGGRESSIVE'
    elif avg_cpu < 20 and max_cpu < 50:
        return 'DOWNSIZE'
    elif avg_cpu > 70:
        return 'UPSIZE'
    else:
        return 'OK'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

┌─────────────────────────────────────────────────────────────┐
│                    Matrice de décision                      │
├─────────────────┬───────────────────────────────────────────┤
│                 │         Utilisation max                   │
│                 │   < 30%    │  30-70%   │    > 70%        │
├─────────────────┼────────────┼───────────┼─────────────────┤
│ Utilisation     │            │           │                 │
│ moyenne         │            │           │                 │
│   < 20%         │ Réduire    │ Réduire   │ Auto-scale     │
│                 │ de 50%     │ de 25%    │                │
│  20-50%         │ Réduire    │ OK        │ Surveiller     │
│                 │ de 25%     │           │                │
│   > 50%         │ Surveiller │ OK        │ Augmenter?     │
└─────────────────┴────────────┴───────────┴─────────────────┘

1
2
3
4
5

Graviton3 vs équivalent x86 :
- Performance : équivalente ou supérieure
- Consommation : -60%
- Coût : -40%
- Recommandation : privilégier Graviton pour nouveaux workloads

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Launch Template avec Spot
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  SpotFleet:
    Type: AWS::EC2::SpotFleet
    Properties:
      SpotFleetRequestConfigData:
        IamFleetRole: !GetAtt SpotFleetRole.Arn
        TargetCapacity: 10
        AllocationStrategy: capacityOptimized  # Choisit les moins susceptibles d'interruption
        LaunchTemplateConfigs:
          - LaunchTemplateSpecification:
              LaunchTemplateId: !Ref LaunchTemplate
              Version: !GetAtt LaunchTemplate.LatestVersionNumber
            Overrides:
              - InstanceType: m5.large
              - InstanceType: m5a.large
              - InstanceType: m4.large

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Handler d'interruption spot
import requests
import signal
import sys

def check_spot_interruption():
    """Vérifie si une interruption est imminente"""
    try:
        response = requests.get(
            'http://169.254.169.254/latest/meta-data/spot/instance-action',
            timeout=1
        )
        if response.status_code == 200:
            return response.json()
    except:
        pass
    return None

def graceful_shutdown(signum, frame):
    """Arrêt propre avant interruption"""
    print("Interruption spot détectée, sauvegarde en cours...")
    save_checkpoint()
    cleanup_resources()
    sys.exit(0)

# Enregistrer le handler
signal.signal(signal.SIGTERM, graceful_shutdown)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

AutoScalingGroup:
  Type: AWS::AutoScaling::AutoScalingGroup
  Properties:
    MinSize: 1
    MaxSize: 20
    DesiredCapacity: 2
    # Mixed instances pour résilience et économie
    MixedInstancesPolicy:
      InstancesDistribution:
        OnDemandBaseCapacity: 1
        OnDemandPercentageAboveBaseCapacity: 20
        SpotAllocationStrategy: capacity-optimized
      LaunchTemplate:
        LaunchTemplateSpecification:
          LaunchTemplateId: !Ref LaunchTemplate
          Version: !GetAtt LaunchTemplate.LatestVersionNumber
        Overrides:
          - InstanceType: t3.medium
          - InstanceType: t3a.medium

ScaleOutPolicy:
  Type: AWS::AutoScaling::ScalingPolicy
  Properties:
    AutoScalingGroupName: !Ref AutoScalingGroup
    PolicyType: TargetTrackingScaling
    TargetTrackingConfiguration:
      PredefinedMetricSpecification:
        PredefinedMetricType: ASGAverageCPUUtilization
      TargetValue: 60  # Maintenir ~60% d'utilisation
      ScaleInCooldown: 300
      ScaleOutCooldown: 60

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# AWS Predictive Scaling
PredictiveScalingPolicy:
  Type: AWS::AutoScaling::ScalingPolicy
  Properties:
    AutoScalingGroupName: !Ref AutoScalingGroup
    PolicyType: PredictiveScaling
    PredictiveScalingConfiguration:
      MetricSpecifications:
        - TargetValue: 60
          PredefinedMetricPairSpecification:
            PredefinedMetricType: ASGCPUUtilization
      Mode: ForecastAndScale
      SchedulingBufferTime: 300  # Provisionner 5min à l'avance

1
2
3

Heures/semaine avec scheduling : 8h × 5j = 40h
Heures/semaine sans scheduling : 24h × 7j = 168h
Économie : 76% de réduction

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Définition d'un schedule
Schedules:
  - Name: office-hours
    Timezone: Europe/Paris
    Periods:
      - BeginTime: "08:00"
        EndTime: "19:00"
        WeekDays: Mon-Fri

# Tags sur les instances
Tags:
  - Key: Schedule
    Value: office-hours

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import boto3

ec2 = boto3.client('ec2')

def lambda_handler(event, context):
    action = event.get('action', 'stop')

    # Trouver les instances avec le tag Environment=dev
    instances = ec2.describe_instances(
        Filters=[
            {'Name': 'tag:Environment', 'Values': ['dev', 'test']},
            {'Name': 'instance-state-name', 'Values': ['running' if action == 'stop' else 'stopped']}
        ]
    )

    instance_ids = [
        i['InstanceId']
        for r in instances['Reservations']
        for i in r['Instances']
    ]

    if instance_ids:
        if action == 'stop':
            ec2.stop_instances(InstanceIds=instance_ids)
        else:
            ec2.start_instances(InstanceIds=instance_ids)

    return {'stopped_instances': len(instance_ids)}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import boto3
from datetime import datetime, timedelta

def find_orphaned_resources():
    ec2 = boto3.client('ec2')
    orphans = []

    # Volumes non attachés
    volumes = ec2.describe_volumes(
        Filters=[{'Name': 'status', 'Values': ['available']}]
    )
    for vol in volumes['Volumes']:
        age = (datetime.now(vol['CreateTime'].tzinfo) - vol['CreateTime']).days
        if age > 7:  # Non attaché depuis 7 jours
            orphans.append({
                'type': 'volume',
                'id': vol['VolumeId'],
                'age_days': age,
                'size_gb': vol['Size'],
                'monthly_cost': vol['Size'] * 0.10  # ~$0.10/GB/mois
            })

    # Elastic IPs non associées
    eips = ec2.describe_addresses()
    for eip in eips['Addresses']:
        if 'AssociationId' not in eip:
            orphans.append({
                'type': 'elastic_ip',
                'id': eip['AllocationId'],
                'monthly_cost': 3.65  # ~$0.005/heure
            })

    return orphans

1
2

Inférence simple → T4 (70W) plutôt que A100 (400W)
Économie : 82% d'énergie

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# PyTorch avec mixed precision
from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for data, target in dataloader:
    optimizer.zero_grad()

    with autocast():  # FP16 automatique
        output = model(data)
        loss = criterion(output, target)

    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

# Réduction mémoire : ~50%
# Accélération : ~2x
# Énergie : ~50% de moins par epoch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Quantization INT8 pour l'inférence
import torch.quantization

model_fp32 = load_model()
model_int8 = torch.quantization.quantize_dynamic(
    model_fp32,
    {torch.nn.Linear},
    dtype=torch.qint8
)

# Réduction taille : ~75%
# Accélération inférence : ~2-4x
# Énergie inférence : ~50-75% de moins

1
2
3
4
5
6
7
8
9

# Mauvais : inférence unitaire
for item in items:
    result = model.predict(item)  # GPU sous-utilisé

# Bon : batch processing
batch_size = 32
for i in range(0, len(items), batch_size):
    batch = items[i:i+batch_size]
    results = model.predict(batch)  # GPU saturé

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Politique de lifecycle S3
lifecycle_policy = {
    'Rules': [
        {
            'ID': 'TierDownOldData',
            'Status': 'Enabled',
            'Filter': {'Prefix': 'data/'},
            'Transitions': [
                {
                    'Days': 30,
                    'StorageClass': 'STANDARD_IA'
                },
                {
                    'Days': 90,
                    'StorageClass': 'GLACIER_IR'
                },
                {
                    'Days': 365,
                    'StorageClass': 'DEEP_ARCHIVE'
                }
            ],
            'Expiration': {
                'Days': 2555  # 7 ans
            }
        }
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# CloudFormation
LogsBucket:
  Type: AWS::S3::Bucket
  Properties:
    BucketName: my-logs-bucket
    LifecycleConfiguration:
      Rules:
        - Id: DeleteOldLogs
          Status: Enabled
          ExpirationInDays: 90
        - Id: TransitionToGlacier
          Status: Enabled
          Prefix: archives/
          Transitions:
            - StorageClass: GLACIER
              TransitionInDays: 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

{
  "rules": [
    {
      "name": "moveToArchive",
      "type": "Lifecycle",
      "definition": {
        "filters": {
          "blobTypes": ["blockBlob"],
          "prefixMatch": ["data/"]
        },
        "actions": {
          "baseBlob": {
            "tierToCool": {"daysAfterModificationGreaterThan": 30},
            "tierToArchive": {"daysAfterModificationGreaterThan": 90},
            "delete": {"daysAfterModificationGreaterThan": 365}
          }
        }
      }
    }
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import hashlib
import boto3

s3 = boto3.client('s3')

def upload_deduplicated(file_path, bucket):
    """Upload avec déduplication côté client"""

    # Calculer le hash
    with open(file_path, 'rb') as f:
        file_hash = hashlib.sha256(f.read()).hexdigest()

    # Vérifier si déjà existant
    try:
        s3.head_object(Bucket=bucket, Key=f'dedup/{file_hash}')
        print(f"Fichier déjà présent, économie de stockage")
        return file_hash
    except:
        pass

    # Upload si nouveau
    s3.upload_file(file_path, bucket, f'dedup/{file_hash}')
    return file_hash

1
2
3
4
5
6
7
8
9

import zstandard as zstd

# Compression niveau 3 (défaut, bon compromis)
cctx = zstd.ZstdCompressor(level=3)
compressed = cctx.compress(data)

# Compression niveau 19 (max, pour archives)
cctx_max = zstd.ZstdCompressor(level=19)
archive_compressed = cctx_max.compress(data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Activation automatique du tiering intelligent
IntelligentTieringConfiguration:
  Type: AWS::S3::Bucket
  Properties:
    BucketName: my-bucket
    IntelligentTieringConfigurations:
      - Id: EntireBucket
        Status: Enabled
        Tierings:
          - AccessTier: ARCHIVE_ACCESS
            Days: 90
          - AccessTier: DEEP_ARCHIVE_ACCESS
            Days: 180

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- PostgreSQL : partitionnement par date
CREATE TABLE events (
    id BIGSERIAL,
    created_at TIMESTAMP NOT NULL,
    data JSONB
) PARTITION BY RANGE (created_at);

-- Partitions actives (SSD)
CREATE TABLE events_2024 PARTITION OF events
    FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');

-- Anciennes partitions → archivage et suppression
-- Export vers S3 puis DROP
\copy events_2023 TO 's3://archive/events_2023.csv.gz' WITH CSV;
DROP TABLE events_2023;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

import boto3
from datetime import datetime, timedelta

def cleanup_orphaned_resources(dry_run=True):
    """Nettoie les ressources orphelines AWS"""

    ec2 = boto3.client('ec2')
    s3 = boto3.client('s3')

    savings = {'monthly_cost': 0, 'storage_gb': 0}

    # 1. Snapshots orphelins (> 90 jours, AMI supprimée)
    print("Analyse des snapshots...")
    snapshots = ec2.describe_snapshots(OwnerIds=['self'])['Snapshots']

    for snap in snapshots:
        age = (datetime.now(snap['StartTime'].tzinfo) - snap['StartTime']).days
        if age > 90:
            # Vérifier si l'AMI existe encore
            try:
                ec2.describe_images(ImageIds=[snap.get('Description', '').split()[-1]])
            except:
                # AMI n'existe plus, snapshot orphelin
                savings['storage_gb'] += snap['VolumeSize']
                savings['monthly_cost'] += snap['VolumeSize'] * 0.05

                if not dry_run:
                    ec2.delete_snapshot(SnapshotId=snap['SnapshotId'])
                print(f"  Snapshot orphelin: {snap['SnapshotId']} ({snap['VolumeSize']}GB, {age} jours)")

    # 2. Volumes non attachés (> 7 jours)
    print("\nAnalyse des volumes...")
    volumes = ec2.describe_volumes(
        Filters=[{'Name': 'status', 'Values': ['available']}]
    )['Volumes']

    for vol in volumes:
        age = (datetime.now(vol['CreateTime'].tzinfo) - vol['CreateTime']).days
        if age > 7:
            savings['storage_gb'] += vol['Size']
            savings['monthly_cost'] += vol['Size'] * 0.10

            if not dry_run:
                ec2.delete_volume(VolumeId=vol['VolumeId'])
            print(f"  Volume orphelin: {vol['VolumeId']} ({vol['Size']}GB, {age} jours)")

    # 3. Cleanup multipart uploads incomplets
    print("\nAnalyse des uploads S3 incomplets...")
    buckets = s3.list_buckets()['Buckets']

    for bucket in buckets:
        try:
            uploads = s3.list_multipart_uploads(Bucket=bucket['Name'])
            for upload in uploads.get('Uploads', []):
                if not dry_run:
                    s3.abort_multipart_upload(
                        Bucket=bucket['Name'],
                        Key=upload['Key'],
                        UploadId=upload['UploadId']
                    )
                print(f"  Upload incomplet: {bucket['Name']}/{upload['Key']}")
        except:
            pass

    print(f"\nRésumé:")
    print(f"  Stockage récupérable: {savings['storage_gb']} GB")
    print(f"  Économie mensuelle: ${savings['monthly_cost']:.2f}")

    return savings

# Exécution en mode dry-run d'abord
cleanup_orphaned_resources(dry_run=True)

1
2
3
4
5
6
7
8
9

# Mauvais : transférer puis filtrer
all_data = fetch_from_remote_db(table='events')
filtered = [e for e in all_data if e['type'] == 'click']

# Bon : filtrer à la source
filtered = fetch_from_remote_db(
    table='events',
    where="type = 'click'"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Mauvais : récupérer tout
response = api.get('/users')  # 10 000 users, 10 MB

# Bon : pagination avec curseur
def get_all_users():
    cursor = None
    while True:
        response = api.get('/users', params={
            'limit': 100,
            'cursor': cursor
        })
        yield from response['users']
        cursor = response.get('next_cursor')
        if not cursor:
            break

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Mauvais : récupérer tout l'objet
query {
  user(id: 123) {
    id name email avatar bio followers following posts comments ...
  }
}

# Bon : seulement ce dont on a besoin
query {
  user(id: 123) {
    id
    name
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

CloudFrontDistribution:
  Type: AWS::CloudFront::Distribution
  Properties:
    DistributionConfig:
      DefaultCacheBehavior:
        # Cache agressif pour assets statiques
        CachePolicyId: !Ref AggressiveCachePolicy
        # Compression automatique
        Compress: true
        ViewerProtocolPolicy: redirect-to-https

      # Origins avec failover
      Origins:
        - Id: S3Origin
          DomainName: !GetAtt Bucket.DomainName
          S3OriginConfig:
            OriginAccessIdentity: !Sub origin-access-identity/cloudfront/${OAI}

      # Prix class : utiliser moins de PoP mais plus proches
      PriceClass: PriceClass_100  # US, Canada, Europe

AggressiveCachePolicy:
  Type: AWS::CloudFront::CachePolicy
  Properties:
    CachePolicyConfig:
      Name: AggressiveCache
      DefaultTTL: 86400      # 1 jour
      MaxTTL: 31536000       # 1 an
      MinTTL: 1
      ParametersInCacheKeyAndForwardedToOrigin:
        CookiesConfig:
          CookieBehavior: none
        HeadersConfig:
          HeaderBehavior: none
        QueryStringsConfig:
          QueryStringBehavior: none

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Configuration Nginx optimale
location /static/ {
    # Assets statiques : cache long
    expires 1y;
    add_header Cache-Control "public, immutable";
}

location /api/ {
    # API : cache court avec revalidation
    add_header Cache-Control "public, max-age=60, stale-while-revalidate=300";
    add_header ETag $request_uri;
}

location / {
    # HTML : pas de cache ou très court
    add_header Cache-Control "no-cache, must-revalidate";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Configuration Nginx
gzip on;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/json
    application/javascript
    application/xml
    application/rss+xml
    image/svg+xml;

# Brotli (meilleur ratio, support moderne)
brotli on;
brotli_comp_level 6;
brotli_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/json
    application/javascript
    application/xml;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Compression des payloads API
import gzip
import json
from flask import Flask, Response

app = Flask(__name__)

@app.route('/api/data')
def get_data():
    data = generate_large_data()
    json_data = json.dumps(data).encode('utf-8')

    # Compresser si le client l'accepte
    if 'gzip' in request.headers.get('Accept-Encoding', ''):
        compressed = gzip.compress(json_data)
        return Response(
            compressed,
            headers={
                'Content-Encoding': 'gzip',
                'Content-Type': 'application/json'
            }
        )

    return Response(json_data, content_type='application/json')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Routage carbon-aware
import requests

REGION_CARBON = {
    'eu-north-1': 30,     # Stockholm
    'eu-west-3': 60,      # Paris
    'ca-central-1': 30,   # Montréal
    'us-east-1': 380,     # N. Virginia
}

def get_optimal_region(user_location, urgency='normal'):
    """Sélectionne la région optimale selon localisation et carbone"""

    candidates = get_nearby_regions(user_location)

    if urgency == 'low':
        # Prioriser le carbone
        return min(candidates, key=lambda r: REGION_CARBON.get(r, 500))
    else:
        # Équilibrer latence et carbone
        scores = {}
        for region in candidates:
            latency = get_latency(user_location, region)
            carbon = REGION_CARBON.get(region, 500)
            scores[region] = latency * 0.7 + carbon * 0.3

        return min(scores, key=scores.get)