Comment maîtriser la gestion avancée des coûts AWS en 2026

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ce:*",
        "budgets:ViewBudget",
        "budgets:Describe*",
        "budgets:CreateBudget",
        "budgets:UpdateBudget",
        "budgets:CreateNotification",
        "budgets:UpdateNotification",
        "sns:Publish",
        "tagpolicies:TagResources",
        "cur:DescribeReportDefinitions",
        "cur:PutReportDefinition"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iam:CreatePolicy",
        "iam:AttachRolePolicy",
        "lambda:*",
        "cloudwatch:PutMetricAlarm",
        "cloudwatch:GetMetricData"
      ],
      "Resource": "*"
    }
  ]
}

#!/bin/bash

# Configurez vos credentials (utilisez MFA si possible)
aws configure set aws_access_key_id YOUR_ACCESS_KEY
aws configure set aws_secret_access_key YOUR_SECRET_KEY
aws configure set default.region us-east-1

# Test : Listez les budgets existants
aws budgets describe-budgets --account-id $(aws sts get-caller-identity --query Account --output text) --max-results 10

# Test Cost Explorer : Get coût total du mois dernier (format JSON)
aws ce get-cost-and-usage \
  --time-period Start=2026-01-01,End=2026-01-31 \
  --granularity MONTHLY \
  --metrics "BlendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE

import boto3
import pandas as pd
from datetime import datetime, timedelta

ce = boto3.client('ce')
end = datetime.now()
start = end - timedelta(days=30)

response = ce.get_cost_and_usage(
    TimePeriod={'Start': start.strftime('%Y-%m-%d'), 'End': end.strftime('%Y-%m-%d')},
    Granularity='DAILY',
    Metrics=['BlendedCost'],
    GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
)

df = pd.json_normalize(response['ResultsByTime'])
print(df[['TimePeriod.Start', 'Total.BlendedCost.Amount', 'GroupBy']].head(10))

# Sauvegarde CSV pour Excel/Tableau
df.to_csv('costs_by_service.csv', index=False)
print('Analyse exportée dans costs_by_service.csv')

import boto3
from datetime import datetime, timedelta

budgets = boto3.client('budgets')
account_id = boto3.client('sts').get_caller_identity()['Account']

sns_topic_arn = 'arn:aws:sns:us-east-1:ACCOUNT:cost-alerts'  # Créez via Console

budgets.create_budget(
    AccountId=account_id,
    Budget={'BudgetName': 'Monthly-Total-5000',
            'BudgetLimit': {'Amount': '5000', 'Unit': 'USD'},
            'TimeUnit': 'MONTHLY',
            'TimePeriod': {'Start': datetime.now().strftime('%Y-%m-01')},
            'CostTypes': {'IncludeTax': True, 'IncludeSubscription': True,
                          'IncludeCredit': False, 'IncludeUpfront': True,
                          'IncludeRecurring': True, 'IncludeRefund': False}},
    NotificationsWithSubscribers=[
        {'Notification': {'NotificationType': 'FORECASTED', 'ComparisonOperator': 'GREATER_THAN',
                          'Threshold': 80.0, 'ThresholdType': 'PERCENTAGE'},
         'Subscribers': [{'SubscriptionType': 'SNS', 'Address': sns_topic_arn}]},
        {'Notification': {'NotificationType': 'ACTUAL', 'ComparisonOperator': 'GREATER_THAN',
                          'Threshold': 100.0, 'ThresholdType': 'PERCENTAGE'},
         'Subscribers': [{'SubscriptionType': 'SNS', 'Address': sns_topic_arn}]}]
)
print('Budget créé avec alertes à 80% forecast / 100% actual.')

import boto3

tag_policies = boto3.client('resourcegroupstaggingapi')
services = ['AmazonEC2', 'AmazonS3', 'AWSLambda']  # Ajoutez services

tags_keys = ['Environment', 'Project', 'Owner']

for service in services:
    tag_policies.activate_tag_policy(
        ServiceId=service,
        TagFilter={'Key': key} for key in tags_keys  # Note: Boucle implicite
    )

print('Tags activés pour granularité coûts :', tags_keys)

# Vérif : Listez tags activés
response = tag_policies.get_tag_policies()
print('Tags actifs:', [p['Targets'][0]['KeyFilters'] for p in response['TagPolicies']])

import boto3
import json
from datetime import datetime, timedelta

def lambda_handler(event, context):
    ce = boto3.client('ce')
    sns = boto3.client('sns')
    end = datetime.now()
    start = end - timedelta(days=7)
    avg_start = end - timedelta(days=14)

    # Coût récent
    recent = ce.get_cost_and_usage(
        TimePeriod={'Start': start.strftime('%Y-%m-%d'), 'End': end.strftime('%Y-%m-%d')},
        Granularity='DAILY', Metrics=['BlendedCost']
    )['ResultsByTime'][-1]['Total']['BlendedCost']['Amount']

    # Moyenne historique
    hist = ce.get_cost_and_usage(
        TimePeriod={'Start': avg_start.strftime('%Y-%m-%d'), 'End': start.strftime('%Y-%m-%d')},
        Granularity='DAILY', Metrics=['BlendedCost']
    )
    avg = sum([d['Total']['BlendedCost']['Amount'] for d in hist['ResultsByTime']]) / 7

    if float(recent) > float(avg) * 1.2:
        sns.publish(TopicArn='arn:aws:sns:us-east-1:ACCOUNT:cost-anomalies',
                    Message=f"Anomalie détectée: {recent} USD vs avg {avg} USD (+{((float(recent)/avg-1)*100):.1f}%)" )
        return {'statusCode': 200, 'body': 'Alerte envoyée'}
    return {'statusCode': 200, 'body': 'Normal'}

# Test local: lambda_handler({}, None)

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  AnomalyDetectorFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Handler: lambda_anomaly_detector.lambda_handler
      Runtime: python3.12
      Policies:
        - Statement:
            - Effect: Allow
              Action:
                - ce:GetCostAndUsage
                - sns:Publish
              Resource: '*'
      Events:
        DailyTrigger:
          Type: Schedule
          Properties:
            Schedule: rate(1 day)

Outputs:
  FunctionArn:
    Value: !GetAtt AnomalyDetectorFunction.Arn