Outils de mesure et d'optimisation

1
2
3
4
5
6
7
8
9

# Extension navigateur
# Chrome : Chrome Web Store → "GreenIT-Analysis"
# Firefox : Addons → "GreenIT-Analysis"

# CLI (pour automation)
npm install -g ecoindex-cli

# Vérifier l'installation
ecoindex-cli --version

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

# Analyser une URL
ecoindex-cli analyze --url https://example.com

# Analyser plusieurs URLs
ecoindex-cli analyze --url https://example.com --url https://example.com/about

# Depuis un fichier
echo "https://example.com" > urls.txt
echo "https://example.com/about" >> urls.txt
ecoindex-cli analyze --url-file urls.txt

# Export JSON
ecoindex-cli analyze --url https://example.com --output json > report.json

# Export CSV
ecoindex-cli analyze --url-file urls.txt --export csv --output-file results.csv

 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

# .github/workflows/ecoindex.yml
name: EcoIndex Check

on: [push, pull_request]

jobs:
  ecoindex:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install ecoindex-cli
        run: npm install -g ecoindex-cli

      - name: Run EcoIndex analysis
        run: |
          ecoindex-cli analyze \
            --url ${{ vars.STAGING_URL }} \
            --output json > ecoindex-report.json

      - name: Check score threshold
        run: |
          SCORE=$(jq '.score' ecoindex-report.json)
          if [ "$SCORE" -lt 50 ]; then
            echo "EcoIndex score $SCORE is below threshold (50)"
            exit 1
          fi
          echo "EcoIndex score: $SCORE"

      - name: Upload report
        uses: actions/upload-artifact@v3
        with:
          name: ecoindex-report
          path: ecoindex-report.json

1
2
3
4
5
6
7
8

# Via npm
npm install -g lighthouse

# Via Chrome DevTools
# F12 → Onglet "Lighthouse"

# Via extension Chrome
# Chrome Web Store → "Lighthouse"

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

# Audit complet
lighthouse https://example.com --output html --output-path report.html

# Format JSON
lighthouse https://example.com --output json --output-path report.json

# Focus performance uniquement
lighthouse https://example.com --only-categories=performance

# Mode desktop (défaut : mobile)
lighthouse https://example.com --preset=desktop

# Avec throttling réseau
lighthouse https://example.com --throttling.cpuSlowdownMultiplier=4

# Quiet mode (CI)
lighthouse https://example.com --chrome-flags="--headless" --quiet

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

# lighthouserc.js
module.exports = {
  ci: {
    collect: {
      url: ['https://example.com/', 'https://example.com/about'],
      numberOfRuns: 3,
    },
    assert: {
      assertions: {
        'categories:performance': ['error', { minScore: 0.8 }],
        'categories:accessibility': ['error', { minScore: 0.9 }],
        'first-contentful-paint': ['error', { maxNumericValue: 2000 }],
        'largest-contentful-paint': ['error', { maxNumericValue: 2500 }],
        'total-blocking-time': ['error', { maxNumericValue: 200 }],
        'resource-summary:script:size': ['error', { maxNumericValue: 300000 }],
      },
    },
    upload: {
      target: 'temporary-public-storage',
    },
  },
};

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

# .github/workflows/lighthouse.yml
name: Lighthouse CI

on: [push]

jobs:
  lighthouse:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Run Lighthouse CI
        uses: treosh/lighthouse-ci-action@v10
        with:
          urls: |
            https://example.com/
            https://example.com/about
          configPath: ./lighthouserc.js
          uploadArtifacts: true
          temporaryPublicStorage: true

1
2

# API publique (usage modéré)
curl "https://api.websitecarbon.com/site?url=https://example.com"

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

import requests

def get_website_carbon(url):
    response = requests.get(
        "https://api.websitecarbon.com/site",
        params={"url": url}
    )
    data = response.json()
    return {
        'url': data['url'],
        'green': data['green'],  # Hébergeur vert ?
        'bytes': data['bytes'],
        'cleanerThan': data['cleanerThan'],  # Percentile
        'statistics': {
            'co2_per_view': data['statistics']['co2']['grid']['grams'],
            'energy_per_view': data['statistics']['energy']
        }
    }

result = get_website_carbon("https://example.com")
print(f"CO2 par visite: {result['statistics']['co2_per_view']:.2f}g")

1
2
3

docker run -d -p 4000:80 \
  --name webpagetest \
  webpagetest/server

1
2
3
4
5

# Soumettre un test
curl "https://www.webpagetest.org/runtest.php?url=https://example.com&k=YOUR_API_KEY&f=json"

# Récupérer les résultats
curl "https://www.webpagetest.org/jsonResult.php?test=TEST_ID"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Télécharger les plugins depuis les releases GitHub
# https://github.com/green-code-initiative/ecoCode/releases

# Copier dans le dossier extensions/plugins de SonarQube
cp sonar-ecocode-java-plugin-*.jar $SONARQUBE_HOME/extensions/plugins/
cp sonar-ecocode-javascript-plugin-*.jar $SONARQUBE_HOME/extensions/plugins/
cp sonar-ecocode-python-plugin-*.jar $SONARQUBE_HOME/extensions/plugins/

# Redémarrer SonarQube
$SONARQUBE_HOME/bin/linux-x86-64/sonar.sh restart

1
2
3

<!-- Pour activer les règles ecoCode dans un profil -->
<!-- Administration → Quality Profiles → Create → Copy from Sonar way -->
<!-- Activer les règles avec le tag "ecocode" -->

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

# .github/workflows/sonar.yml
name: SonarQube Analysis

on: [push, pull_request]

jobs:
  sonar:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: SonarQube Scan
        uses: sonarsource/sonarqube-scan-action@master
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}

      - name: Check Quality Gate
        uses: sonarsource/sonarqube-quality-gate-action@master
        timeout-minutes: 5
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

1

pip install codecarbon

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

from codecarbon import EmissionsTracker

# Méthode 1 : Context manager
with EmissionsTracker() as tracker:
    # Votre code
    model.fit(X_train, y_train)

# Méthode 2 : Explicite
tracker = EmissionsTracker()
tracker.start()
# Votre code
model.fit(X_train, y_train)
emissions = tracker.stop()
print(f"Emissions: {emissions} kg CO2eq")

1
2
3
4
5
6
7
8
9

from codecarbon import track_emissions

@track_emissions(project_name="training", output_dir="./emissions")
def train_model(X, y):
    model = RandomForestClassifier()
    model.fit(X, y)
    return model

model = train_model(X_train, y_train)

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

from codecarbon import EmissionsTracker

tracker = EmissionsTracker(
    project_name="mon_projet",
    measure_power_secs=15,      # Intervalle de mesure
    tracking_mode="process",     # 'process' ou 'machine'
    log_level="warning",
    save_to_file=True,
    output_dir="./emissions",
    save_to_api=False,          # Envoyer à l'API CodeCarbon
    gpu_ids=[0, 1],             # GPUs à tracker
    emissions_endpoint=None,     # Endpoint custom
    experiment_id=None,
    country_iso_code="FRA",     # Override la détection auto
    region=None,
    cloud_provider="aws",       # aws, gcp, azure
    cloud_region="eu-west-3",
)

1
2
3
4
5
6
7
8
9

# .codecarbon.config
[codecarbon]
project_name = mon_projet
output_dir = ./emissions
save_to_file = true
save_to_api = false
log_level = warning
tracking_mode = machine
measure_power_secs = 15

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import pandas as pd

# Lire les emissions
df = pd.read_csv("emissions/emissions.csv")

# Analyse par run
print(df.groupby('project_name')['emissions'].sum())

# Évolution temporelle
df['timestamp'] = pd.to_datetime(df['timestamp'])
df.set_index('timestamp')['emissions'].plot()

1
2
3

git clone https://github.com/green-coding-berlin/green-metrics-tool.git
cd green-metrics-tool
docker-compose up -d

 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

name: Mon Application
author: equipe@example.com
description: Test de performance énergétique

compose-file: docker-compose.yml

sci:
  R_d: Request

flow:
  - name: Startup
    container: app
    commands:
      - type: console
        command: sleep 5
        note: Attente démarrage

  - name: Homepage Load
    container: app
    commands:
      - type: web
        url: http://app:8080/
        note: Chargement page d'accueil

  - name: API Call
    container: app
    commands:
      - type: web
        url: http://app:8080/api/data
        note: Appel API

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

# Clone du repository
git clone https://github.com/cloud-carbon-footprint/cloud-carbon-footprint.git
cd cloud-carbon-footprint

# Installation des dépendances
yarn install

# Configuration
cp packages/api/.env.template packages/api/.env
cp packages/client/.env.template packages/client/.env

# Éditer packages/api/.env avec vos credentials

1
2
3
4
5
6
7
8

# .env
AWS_USE_BILLING_DATA=true
AWS_ATHENA_DB_NAME=athenacurcfn_cost_and_usage
AWS_ATHENA_DB_TABLE=cost_and_usage
AWS_ATHENA_REGION=us-east-1
AWS_ATHENA_QUERY_RESULT_LOCATION=s3://my-bucket/athena-results/
AWS_BILLING_ACCOUNT_ID=123456789012
AWS_BILLING_ACCOUNT_NAME=my-account

1
2
3
4
5
6
7

# .env
GCP_USE_BILLING_DATA=true
GCP_USE_CARBON_FREE_ENERGY_PERCENTAGE=true
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
GCP_BIG_QUERY_TABLE=billing_export.gcp_billing_export_v1_XXXXXX
GCP_BILLING_PROJECT_ID=my-project
GCP_BILLING_PROJECT_NAME=My Project

1
2
3
4
5

# Démarrer l'API et le client
yarn start

# Ou avec Docker
docker-compose up

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

import boto3

client = boto3.client('sustainability')

response = client.get_carbon_footprint_summary(
    dateRange={
        'startDate': '2024-01-01',
        'endDate': '2024-12-31'
    }
)

print(f"Total emissions: {response['totalCarbonEmissions']} kg CO2e")

1
2

# Télécharger le template depuis
# https://github.com/Azure/azure-sustainability

1
2
3
4
5
6
7
8

SELECT
  usage_month,
  service.description,
  location.location,
  carbon_footprint_total_kgCO2e.location_based as emissions_kg
FROM `project.dataset.carbon_footprint_*`
WHERE usage_month >= '2024-01'
ORDER BY emissions_kg DESC

1
2
3
4
5
6
7

helm repo add kepler https://sustainable-computing-io.github.io/kepler-helm-chart
helm repo update

helm install kepler kepler/kepler \
  --namespace kepler \
  --create-namespace \
  --set serviceMonitor.enabled=true

1

kubectl apply -f https://raw.githubusercontent.com/sustainable-computing-io/kepler/main/manifests/kubernetes/deployment.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Consommation par pod (joules)
kepler_container_joules_total{container_name="my-app"}

# Par namespace
sum(rate(kepler_container_joules_total[5m])) by (namespace)

# Conversion en Watts
sum(rate(kepler_container_joules_total[1m])) by (pod_name)

# Top 10 pods par consommation
topk(10, sum(rate(kepler_container_joules_total[5m])) by (pod_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

{
  "dashboard": {
    "title": "Kepler Energy Dashboard",
    "panels": [
      {
        "title": "Total Power Consumption (Watts)",
        "type": "stat",
        "targets": [{
          "expr": "sum(rate(kepler_container_joules_total[1m]))"
        }]
      },
      {
        "title": "Power by Namespace",
        "type": "piechart",
        "targets": [{
          "expr": "sum(rate(kepler_container_joules_total[5m])) by (namespace)",
          "legendFormat": "{{namespace}}"
        }]
      },
      {
        "title": "Power Trend",
        "type": "timeseries",
        "targets": [{
          "expr": "sum(rate(kepler_container_joules_total[5m])) by (namespace)"
        }]
      }
    ]
  }
}

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

# Via cargo
cargo install scaphandre

# Via package (Debian/Ubuntu)
wget https://github.com/hubblo-org/scaphandre/releases/download/v1.0.0/scaphandre_1.0.0_amd64.deb
sudo dpkg -i scaphandre_1.0.0_amd64.deb

# Via Docker
docker run -d \
  --name scaphandre \
  -v /sys/class/powercap:/sys/class/powercap \
  -v /proc:/proc \
  -p 8080:8080 \
  hubblo/scaphandre prometheus

1

scaphandre prometheus --port 8080 --host 0.0.0.0

1
2
3
4
5
6
7
8

# Puissance totale hôte (microwatts)
scaphandre_host_power_microwatts

# Par process
scaphandre_process_power_consumption_microwatts{exe="python"}

# Énergie cumulée
scaphandre_host_energy_microjoules

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

npm install -g @aspect/squoosh

# Convertir en WebP
squoosh-cli --webp '{"quality":80}' image.jpg

# Convertir en AVIF
squoosh-cli --avif '{"quality":75}' image.jpg

# Redimensionner
squoosh-cli --resize '{"width":800}' --webp '{}' image.jpg

1

npm install sharp

 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

const sharp = require('sharp');

// Conversion WebP
await sharp('input.jpg')
  .webp({ quality: 80 })
  .toFile('output.webp');

// Redimensionnement responsive
const sizes = [320, 640, 1024, 1920];
for (const width of sizes) {
  await sharp('input.jpg')
    .resize(width)
    .webp({ quality: 80 })
    .toFile(`output-${width}.webp`);
}

// Pipeline complet
await sharp('input.jpg')
  .resize(800, 600, { fit: 'inside' })
  .webp({ quality: 80, effort: 6 })
  .toBuffer()
  .then(data => {
    console.log(`Output size: ${data.length} bytes`);
  });

// AVIF (meilleure compression)
await sharp('input.jpg')
  .avif({ quality: 65, effort: 9 })
  .toFile('output.avif');

 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

const sharp = require('sharp');
const glob = require('glob');
const path = require('path');

async function optimizeImages() {
  const images = glob.sync('src/images/**/*.{jpg,jpeg,png}');

  for (const image of images) {
    const baseName = path.basename(image, path.extname(image));
    const outDir = 'dist/images';

    // Version WebP
    await sharp(image)
      .resize(1920, null, { withoutEnlargement: true })
      .webp({ quality: 80 })
      .toFile(`${outDir}/${baseName}.webp`);

    // Version AVIF (fallback)
    await sharp(image)
      .resize(1920, null, { withoutEnlargement: true })
      .avif({ quality: 65 })
      .toFile(`${outDir}/${baseName}.avif`);

    // Version originale optimisée
    await sharp(image)
      .resize(1920, null, { withoutEnlargement: true })
      .jpeg({ quality: 80, progressive: true })
      .toFile(`${outDir}/${baseName}.jpg`);

    console.log(`Optimized: ${baseName}`);
  }
}

optimizeImages();

1

npm install -g svgo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Optimiser un fichier
svgo input.svg -o output.svg

# Optimiser un dossier
svgo -f ./icons -o ./icons-optimized

# Afficher les stats
svgo input.svg --show-plugins

# Configuration personnalisée
svgo input.svg --config svgo.config.js

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

// svgo.config.js
module.exports = {
  plugins: [
    'preset-default',
    'removeDimensions',
    {
      name: 'removeAttrs',
      params: {
        attrs: '(fill|stroke)'
      }
    },
    {
      name: 'addAttributesToSVGElement',
      params: {
        attributes: [{ 'aria-hidden': 'true' }]
      }
    }
  ]
};

1

npm install @axe-core/cli

1
2
3
4
5
6
7
8

# Audit d'une URL
axe https://example.com

# Avec règles spécifiques
axe https://example.com --rules color-contrast,image-alt

# Export JSON
axe https://example.com --save report.json

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

const { AxePuppeteer } = require('@axe-core/puppeteer');
const puppeteer = require('puppeteer');

describe('Accessibility', () => {
  it('should have no accessibility violations', async () => {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    await page.goto('https://example.com');

    const results = await new AxePuppeteer(page).analyze();

    expect(results.violations).toHaveLength(0);

    await browser.close();
  });
});

1
2

npm install -g pa11y
npm install -g pa11y-ci

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Test simple
pa11y https://example.com

# Avec standard spécifique
pa11y https://example.com --standard WCAG2AA

# Format JSON
pa11y https://example.com --reporter json > report.json

# Ignorer certaines règles
pa11y https://example.com --ignore "WCAG2AA.Principle1.Guideline1_1.1_1_1.H37"

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

// .pa11yci
{
  "defaults": {
    "standard": "WCAG2AA",
    "timeout": 10000,
    "wait": 1000
  },
  "urls": [
    "https://example.com/",
    "https://example.com/about",
    {
      "url": "https://example.com/login",
      "actions": [
        "set field #username to test@example.com",
        "click element #submit"
      ]
    }
  ]
}

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

# .github/workflows/a11y.yml
name: Accessibility

on: [push]

jobs:
  pa11y:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Run Pa11y CI
        run: |
          npm install -g pa11y-ci
          pa11y-ci

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

# Exemple de calcul avec les facteurs NegaOctet
facteurs = {
    'laptop_fabrication_kg_co2e': 300,
    'laptop_usage_kwh_an': 25,
    'ecran_fabrication_kg_co2e': 350,
    'ecran_usage_kwh_an': 35,
    'kwh_france_kg_co2e': 0.057
}

def calculer_empreinte_poste(duree_vie_ans=5):
    # Fabrication (amorti sur durée de vie)
    fab_laptop = facteurs['laptop_fabrication_kg_co2e'] / duree_vie_ans
    fab_ecran = facteurs['ecran_fabrication_kg_co2e'] / 7  # 7 ans pour écran

    # Usage annuel
    usage_laptop = facteurs['laptop_usage_kwh_an'] * facteurs['kwh_france_kg_co2e']
    usage_ecran = facteurs['ecran_usage_kwh_an'] * facteurs['kwh_france_kg_co2e']

    total = fab_laptop + fab_ecran + usage_laptop + usage_ecran
    return total

print(f"Empreinte poste de travail : {calculer_empreinte_poste():.1f} kg CO2e/an")

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

# Exemple requête API
curl -X POST "https://api.boavizta.org/v1/server/" \
  -H "Content-Type: application/json" \
  -d '{
    "model": {
      "type": "rack"
    },
    "configuration": {
      "cpu": {"units": 2, "core_units": 24},
      "ram": [{"units": 12, "capacity": 32}],
      "disk": [{"units": 4, "capacity": 1000, "type": "ssd"}]
    },
    "usage": {
      "years_use_time": 5,
      "usage_location": "FRA"
    }
  }'

 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

# .github/workflows/eco-ci.yml
name: Build with Carbon Tracking

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Initialize Eco-CI
        uses: green-coding-solutions/eco-ci-energy-estimation@v3
        with:
          task: start-measurement

      - name: Build
        run: npm run build

      - name: Tests
        run: npm test

      - name: Get Measurement
        uses: green-coding-solutions/eco-ci-energy-estimation@v3
        with:
          task: get-measurement
          label: "build-and-test"

      - name: Show Results
        uses: green-coding-solutions/eco-ci-energy-estimation@v3
        with:
          task: display-results

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

MESURE
├── EcoIndex CLI (audit rapide)
├── Lighthouse (performance)
└── axe DevTools (accessibilité)

BUILD
├── Sharp (optimisation images)
├── SVGO (optimisation SVG)
└── Bundler avec tree-shaking

CI/CD
├── Lighthouse CI
├── EcoIndex CI
└── Pa11y CI

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

MESURE
├── CodeCarbon (Python)
├── JoularJX (Java)
└── Profilers énergétiques

ANALYSE
├── SonarQube + ecoCode
└── Green Metrics Tool

CI/CD
├── Tests de performance
├── Seuils d'énergie
└── Eco-CI

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

INFRASTRUCTURE
├── Kepler (Kubernetes)
├── Scaphandre (serveurs)
└── Cloud Carbon Footprint

MONITORING
├── Prometheus + Grafana
├── Alertes consommation
└── Dashboards énergie

OPTIMISATION
├── Right-sizing automatisé
├── Scheduling
└── FinOps tools

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

BILAN
├── Fruggr ou Verdikt
├── NegaOctet (facteurs)
└── Boavizta API

REPORTING
├── Dashboard consolidé
├── Export CSRD
└── Benchmarks sectoriels

GOUVERNANCE
├── Indicateurs suivis
├── Plans d'action
└── Communication