GreenOps: Infrastruttura Carbon-Aware con Kubernetes

# carbon-aware-keda-operator/config/samples/carbonawarekedascaler.yaml
# Installa l'operator: kubectl apply -f https://github.com/Azure/carbon-aware-keda-operator/releases/latest/download/operator.yaml

apiVersion: carbon.azure.com/v1alpha1
kind: CarbonAwareKedaScaler
metadata:
  name: batch-processor-carbon-scaler
  namespace: default
spec:
  # Riferimento al KEDA ScaledObject da modificare
  kedaTarget:
    apiVersion: keda.sh/v1alpha1
    kind: ScaledObject
    name: batch-processor-scaler

  # Definisce come il ceiling di repliche cambia con la carbon intensity
  carbonIntensityForecastDataSource:
    mockCarbonForecast: false
    localConfigMap:
      name: carbon-intensity-forecast
      namespace: kube-system
      key: data

  # Soglie carbon intensity (gCO2/kWh) -> max replicas
  maxReplicasByCarbonIntensity:
    - carbonIntensityThreshold: 50     # Energia molto pulita
      maxReplicas: 20                   # Scala aggressivamente
    - carbonIntensityThreshold: 100    # Energia mediamente pulita
      maxReplicas: 15
    - carbonIntensityThreshold: 200    # Mix energetico moderato
      maxReplicas: 10
    - carbonIntensityThreshold: 350    # Carbon-intensive
      maxReplicas: 5                    # Scala al minimo
    - carbonIntensityThreshold: 500    # Molto carbon-intensive
      maxReplicas: 2                    # Solo carichi critici

# keda-scaled-object.yaml
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: batch-processor-scaler
  namespace: default
spec:
  scaleTargetRef:
    name: batch-processor
  minReplicaCount: 2
  maxReplicaCount: 20   # Viene sovrascritto dal CarbonAwareKedaScaler
  cooldownPeriod: 300
  pollingInterval: 60
  triggers:
    - type: rabbitmq
      metadata:
        protocol: amqp
        queueName: batch-jobs
        mode: QueueLength
        value: "10"
      authenticationRef:
        name: rabbitmq-trigger-auth

---
# Deployment del batch processor
apiVersion: apps/v1
kind: Deployment
metadata:
  name: batch-processor
  namespace: default
  labels:
    app: batch-processor
    green-software: "true"
spec:
  replicas: 2
  selector:
    matchLabels:
      app: batch-processor
  template:
    metadata:
      labels:
        app: batch-processor
      annotations:
        # Annotazione per tracking GreenOps
        greenops.io/workload-type: "deferrable-batch"
        greenops.io/carbon-policy: "carbon-aware-scaling"
    spec:
      containers:
        - name: batch-processor
          image: myregistry/batch-processor:v1.2.0
          resources:
            requests:
              cpu: "500m"
              memory: "512Mi"
            limits:
              cpu: "2000m"
              memory: "2Gi"

# carbon-intensity-exporter.yaml
# Installa: kubectl apply -f https://github.com/Azure/kubernetes-carbon-intensity-exporter/releases/latest/download/deploy.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: carbon-intensity-exporter-config
  namespace: kube-system
data:
  # Provider dati: WattTime o ElectricityMaps
  CARBON_INTENSITY_PROVIDER: "WattTime"
  # Region/location in formato standard (ISO3166-1)
  LOCATION: "eastus"
  # Aggiornamento ogni 12 ore con forecast 24h
  FETCH_INTERVAL_SECONDS: "43200"

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: carbon-intensity-exporter
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: carbon-intensity-exporter
  template:
    metadata:
      labels:
        app: carbon-intensity-exporter
    spec:
      serviceAccountName: carbon-intensity-exporter
      containers:
        - name: exporter
          image: ghcr.io/azure/kubernetes-carbon-intensity-exporter:latest
          envFrom:
            - configMapRef:
                name: carbon-intensity-exporter-config
          env:
            - name: WATTTIME_USERNAME
              valueFrom:
                secretKeyRef:
                  name: carbon-intensity-secrets
                  key: watttime-username
            - name: WATTTIME_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: carbon-intensity-secrets
                  key: watttime-password

#!/usr/bin/env python3
# carbon_aware_scheduler.py
# Richiede: pip install kubernetes requests python-crontab

import os
import json
import logging
from datetime import datetime, timedelta
from typing import Optional
import requests
from kubernetes import client, config

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("carbon-aware-scheduler")

CARBON_AWARE_SDK_URL = os.getenv("CARBON_AWARE_SDK_URL", "http://carbon-aware-sdk:8080")
CARBON_THRESHOLD = float(os.getenv("CARBON_THRESHOLD_G_CO2_KWH", "150"))


def get_best_window(location: str, duration_minutes: int = 60) -> Optional[datetime]:
    """Interroga il Carbon Aware SDK per la finestra ottimale nelle prossime 24h."""
    window_start = datetime.utcnow()
    window_end = window_start + timedelta(hours=24)

    url = f"{CARBON_AWARE_SDK_URL}/emissions/forecasts/best"
    params = {
        "location": location,
        "dataStartAt": window_start.isoformat() + "Z",
        "dataEndAt": window_end.isoformat() + "Z",
        "windowSize": duration_minutes,
    }

    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        data = response.json()

        # Il Carbon Aware SDK restituisce la finestra ottimale
        if data and len(data) > 0:
            best = data[0]
            optimal_time_str = best.get("optimalDataPoints", [{}])[0].get("timestamp")
            if optimal_time_str:
                return datetime.fromisoformat(optimal_time_str.replace("Z", "+00:00"))
    except requests.RequestException as e:
        logger.error(f"Errore Carbon Aware SDK: {e}")
    return None


def update_cronjob_schedule(namespace: str, cronjob_name: str, target_time: datetime) -> bool:
    """Aggiorna la schedule del CronJob Kubernetes."""
    config.load_incluster_config()
    batch_v1 = client.BatchV1Api()

    # Converti in espressione cron (minuto e ora UTC)
    cron_expression = f"{target_time.minute} {target_time.hour} * * *"

    try:
        cronjob = batch_v1.read_namespaced_cron_job(cronjob_name, namespace)
        cronjob.spec.schedule = cron_expression

        # Annotazione per audit trail GreenOps
        if cronjob.metadata.annotations is None:
            cronjob.metadata.annotations = {}
        cronjob.metadata.annotations["greenops.io/last-schedule-update"] = datetime.utcnow().isoformat()
        cronjob.metadata.annotations["greenops.io/scheduled-carbon-window"] = target_time.isoformat()

        batch_v1.patch_namespaced_cron_job(cronjob_name, namespace, cronjob)
        logger.info(f"CronJob {cronjob_name} aggiornato: schedule={cron_expression}")
        return True
    except client.ApiException as e:
        logger.error(f"Errore aggiornamento CronJob: {e}")
        return False


if __name__ == "__main__":
    location = os.getenv("GRID_LOCATION", "IT")
    namespace = os.getenv("TARGET_NAMESPACE", "default")
    cronjob_name = os.getenv("TARGET_CRONJOB", "ml-training-job")
    job_duration = int(os.getenv("JOB_DURATION_MINUTES", "90"))

    best_window = get_best_window(location, job_duration)
    if best_window:
        logger.info(f"Finestra ottimale trovata: {best_window}")
        update_cronjob_schedule(namespace, cronjob_name, best_window)
    else:
        logger.warning("Nessuna finestra ottimale trovata, mantengo schedule corrente")

# priority-classes-greenops.yaml
# Gerarchia di priorità GreenOps

# Workload critici: sempre in esecuzione, non deferrabili
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: greenops-critical
  annotations:
    greenops.io/deferrable: "false"
    greenops.io/carbon-policy: "always-run"
value: 1000000
globalDefault: false
description: "Workload critici: API user-facing, servizi core business"

---
# Workload standard: possono aspettare finestre verdi brevi (1-2h)
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: greenops-standard
  annotations:
    greenops.io/deferrable: "true"
    greenops.io/max-defer-hours: "2"
    greenops.io/carbon-threshold: "200"
value: 500000
globalDefault: true
description: "Workload standard: servizi interni, analytics real-time"

---
# Workload batch: ottimizzati per finestre verdi lunghe (fino a 12h)
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: greenops-batch
  annotations:
    greenops.io/deferrable: "true"
    greenops.io/max-defer-hours: "12"
    greenops.io/carbon-threshold: "100"
value: 100000
globalDefault: false
description: "Workload batch: ETL, training ML, report, backup"

---
# Workload opportunistici: solo durante energia molto pulita
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: greenops-opportunistic
  annotations:
    greenops.io/deferrable: "true"
    greenops.io/max-defer-hours: "48"
    greenops.io/carbon-threshold: "80"
value: 10000
globalDefault: false
description: "Workload opportunistici: pre-training, batch mensili, archivio"

# Struttura del setup Karmada multi-cluster
#
# karmada-control-plane (hub)
# ├── cluster-eu-north-1     (Stoccolma - 15-40 gCO2/kWh)
# ├── cluster-eu-west-1      (Irlanda - 100-250 gCO2/kWh)
# ├── cluster-us-west-2      (Oregon - 50-150 gCO2/kWh, molto rinnovabili)
# └── cluster-us-east-1      (Virginia - 300-400 gCO2/kWh)
#
# PropagationPolicy determina dove gira il workload in base a carbon intensity

apiVersion: policy.karmada.io/v1alpha1
kind: PropagationPolicy
metadata:
  name: ml-training-carbon-routing
  namespace: ml-workloads
  annotations:
    greenops.io/routing-strategy: "carbon-optimized"
spec:
  resourceSelectors:
    - apiVersion: batch/v1
      kind: Job
      labelSelector:
        matchLabels:
          workload-type: "ml-training"
          greenops/deferrable: "true"
  placement:
    clusterAffinity:
      # Preferenza ordinata per carbon intensity (aggiornata dal carbon-router)
      clusterNames:
        - cluster-eu-north-1    # Prima scelta: Svezia (sempre verde)
        - cluster-us-west-2     # Seconda: Oregon (molto rinnovabili)
        - cluster-eu-west-1     # Terza: Irlanda (mediamente verde)
        - cluster-us-east-1     # Ultima: Virginia (carbon-intensive)
    replicaScheduling:
      replicaSchedulingType: Duplicated
      # Non divisibile: il job va su UN cluster, quello più verde

#!/usr/bin/env python3
# carbon_router.py - Aggiorna la PropagationPolicy Karmada in base alla carbon intensity
# Eseguito ogni ora da un CronJob nel control plane

import os
import json
import requests
import logging
from typing import Dict, List, Tuple
from kubernetes import client, config
from kubernetes.client.rest import ApiException

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("carbon-router")

CARBON_SDK_URL = os.getenv("CARBON_SDK_URL", "http://carbon-aware-sdk:8080")

# Mapping cluster -> location ElectricityMaps/WattTime
CLUSTER_LOCATIONS: Dict[str, str] = {
    "cluster-eu-north-1": "SE",   # Svezia
    "cluster-eu-west-1": "IE",    # Irlanda
    "cluster-us-west-2": "US-NW", # Pacific Northwest
    "cluster-us-east-1": "US-MIDA", # Mid-Atlantic
}


def fetch_carbon_intensity(location: str) -> float:
    """Recupera carbon intensity corrente per una location."""
    url = f"{CARBON_SDK_URL}/emissions/bylocation"
    params = {"location": location}
    try:
        r = requests.get(url, params=params, timeout=8)
        r.raise_for_status()
        data = r.json()
        if data:
            return float(data[0].get("rating", 999.0))
    except Exception as e:
        logger.error(f"Impossibile recuperare carbon intensity per {location}: {e}")
    return 999.0  # Valore di fallback: considera come molto carbon-intensive


def rank_clusters_by_carbon() -> List[Tuple[str, float]]:
    """Ordina i cluster dalla carbon intensity più bassa alla più alta."""
    intensities: List[Tuple[str, float]] = []
    for cluster, location in CLUSTER_LOCATIONS.items():
        intensity = fetch_carbon_intensity(location)
        intensities.append((cluster, intensity))
        logger.info(f"{cluster} ({location}): {intensity:.1f} gCO2/kWh")

    intensities.sort(key=lambda x: x[1])
    return intensities


def update_propagation_policy(ranked_clusters: List[Tuple[str, float]]) -> None:
    """Aggiorna la clusterNames nella PropagationPolicy Karmada."""
    # Karmada usa CRD custom - accesso via dynamic client
    config.load_incluster_config()
    dynamic_client = client.ApiClient()

    # Lista ordinata per il patch
    cluster_names = [c[0] for c in ranked_clusters]

    patch_body = {
        "spec": {
            "placement": {
                "clusterAffinity": {
                    "clusterNames": cluster_names
                }
            }
        }
    }

    # Annota la policy con i dati correnti per audit
    timestamp = __import__("datetime").datetime.utcnow().isoformat()
    patch_body["metadata"] = {
        "annotations": {
            "greenops.io/last-routing-update": timestamp,
            "greenops.io/carbon-ranking": json.dumps(
                [{"cluster": c, "gco2_kwh": round(i, 1)} for c, i in ranked_clusters]
            )
        }
    }

    logger.info(f"Aggiornamento routing: ordine cluster = {cluster_names}")
    # In produzione: usare kubernetes.client.CustomObjectsApi per patch Karmada CRD


if __name__ == "__main__":
    ranked = rank_clusters_by_carbon()
    logger.info("Classifica cluster per carbon intensity:")
    for cluster, intensity in ranked:
        logger.info(f"  {cluster}: {intensity:.1f} gCO2/kWh")
    update_propagation_policy(ranked)

#!/usr/bin/env python3
# azure_carbon_api.py
# Richiede: pip install azure-identity requests

import os
from azure.identity import DefaultAzureCredential
import requests

SUBSCRIPTION_ID = os.environ["AZURE_SUBSCRIPTION_ID"]
CREDENTIAL = DefaultAzureCredential()


def get_azure_carbon_emissions(
    resource_group: str,
    start_date: str,
    end_date: str
) -> dict:
    """
    Recupera emissioni CO2 per resource group tramite Azure Carbon Optimization API.
    API endpoint (2025): https://management.azure.com/providers/Microsoft.Carbon/carbonEmissionReports
    """
    token = CREDENTIAL.get_token("https://management.azure.com/.default").token
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }

    # Azure Carbon Optimization API (GA 2025)
    url = (
        f"https://management.azure.com/subscriptions/{SUBSCRIPTION_ID}"
        f"/resourceGroups/{resource_group}"
        f"/providers/Microsoft.Carbon/carbonEmissionReports"
        f"?api-version=2023-04-01-preview"
    )

    payload = {
        "reportType": "OverallSummaryReport",
        "subscriptionList": [SUBSCRIPTION_ID],
        "carbonScopeList": ["Scope1", "Scope2", "Scope3"],
        "dateRange": {
            "start": start_date,  # "2025-01-01"
            "end": end_date       # "2025-03-01"
        }
    }

    response = requests.post(url, json=payload, headers=headers, timeout=30)
    response.raise_for_status()
    return response.json()


def get_google_carbon_data(project_id: str, dataset: str = "carbon_footprint") -> None:
    """
    Google Cloud esporta i dati carbon footprint in BigQuery automaticamente.
    Abilita: Cloud Billing Export -> BigQuery -> Carbon Footprint
    Query esempio BigQuery:
    """
    bq_query = """
    SELECT
        usage_month,
        service.description AS service,
        location.region AS region,
        SUM(carbon_footprint_kgCO2e.market_based) AS kg_co2e_market_based,
        SUM(carbon_footprint_kgCO2e.location_based) AS kg_co2e_location_based
    FROM
        `{project_id}.{dataset}.carbon_footprint`
    WHERE
        usage_month BETWEEN '2025-01-01' AND '2025-03-31'
    GROUP BY
        usage_month, service, region
    ORDER BY
        kg_co2e_market_based DESC
    """
    print(f"Esegui in BigQuery:\n{bq_query.format(project_id=project_id, dataset=dataset)}")


if __name__ == "__main__":
    # Azure example
    data = get_azure_carbon_emissions(
        resource_group="production-rg",
        start_date="2025-01-01",
        end_date="2025-03-01"
    )
    print(f"Azure Carbon Emissions: {data}")

    # Google BigQuery example
    get_google_carbon_data("my-gcp-project")

# Installazione Kepler con Helm (metodo raccomandato)

# 1. Prerequisiti: Prometheus Operator (o stack kube-prometheus)
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.enabled=true \
  --set alertmanager.enabled=true

# 2. Installa Kepler dal registry OCI (stable)
helm install kepler oci://quay.io/sustainable_computing_io/charts/kepler \
  --namespace kepler \
  --create-namespace \
  --set serviceMonitor.enabled=true \
  --set serviceMonitor.namespace=monitoring \
  --set serviceMonitor.jobLabel=kepler \
  --version 0.5.9  # verifica ultima versione su quay.io

# 3. Verifica che il DaemonSet sia running su tutti i nodi
kubectl get daemonset -n kepler
# Expected: kepler-kepler con DESIRED=N, READY=N

# 4. Verifica raccolta metriche
kubectl port-forward -n kepler svc/kepler-internal 8888:8888 &
curl http://localhost:8888/metrics | grep kepler_container_

# Output atteso:
# kepler_container_joules_total{container_name="...",namespace="...",pod_name="..."}
# kepler_container_cpu_joules_total{...}
# kepler_container_dram_joules_total{...}
# kepler_container_gpu_joules_total{...}

# Query Prometheus per analisi GreenOps con Kepler

# 1. Energia totale per namespace (kWh nell'ultima ora)
sum by (namespace) (
  increase(kepler_container_joules_total[1h])
) / 3600000

# 2. Top 10 pod per consumo energetico (Watt medi ultima ora)
topk(10,
  avg by (pod_name, namespace) (
    rate(kepler_container_joules_total[1h]) * 1000
  )
)

# 3. CO2e per namespace (assumendo carbon intensity 200 gCO2/kWh)
# Sostituisci 200 con il valore real-time da Carbon Aware SDK
sum by (namespace) (
  increase(kepler_container_joules_total[24h])
) / 3600000 * 200 / 1000  # risultato in kgCO2e

# 4. Efficienza energetica: Joule per richiesta HTTP (se hai metriche app)
sum(rate(kepler_container_joules_total[5m])) by (pod_name)
/
sum(rate(http_requests_total[5m])) by (pod_name)

# 5. Alert: pod con consumo energetico anomalo (>50W per 15min)
avg_over_time(
  sum by (pod_name, namespace) (
    kepler_container_watts
  )[15m:1m]
) > 50

# 6. Trend consumo cluster (kWh/giorno ultimi 7 giorni)
sum(increase(kepler_node_package_joules_total[1d])) / 3600000

# grafana-dashboard-greenops.yaml
# ConfigMap con dashboard Grafana per GreenOps
apiVersion: v1
kind: ConfigMap
metadata:
  name: greenops-dashboard
  namespace: monitoring
  labels:
    grafana_dashboard: "1"  # Label per auto-discovery Grafana
data:
  greenops-cluster.json: |
    {
      "title": "GreenOps Cluster Dashboard",
      "panels": [
        {
          "title": "Carbon Intensity Corrente (gCO2/kWh)",
          "type": "stat",
          "targets": [
            {
              "expr": "carbon_intensity_g_co2_kwh",
              "legendFormat": "Carbon Intensity"
            }
          ],
          "thresholds": {
            "steps": [
              {"color": "green", "value": 0},
              {"color": "yellow", "value": 150},
              {"color": "orange", "value": 300},
              {"color": "red", "value": 450}
            ]
          }
        },
        {
          "title": "kWh Cluster (ultima ora)",
          "type": "stat",
          "targets": [
            {
              "expr": "sum(increase(kepler_node_package_joules_total[1h])) / 3600000",
              "legendFormat": "kWh"
            }
          ]
        },
        {
          "title": "kgCO2e Cluster (ultima ora)",
          "type": "stat",
          "targets": [
            {
              "expr": "sum(increase(kepler_node_package_joules_total[1h])) / 3600000 * carbon_intensity_g_co2_kwh / 1000",
              "legendFormat": "kgCO2e"
            }
          ]
        },
        {
          "title": "Top Namespace per Consumo (kWh/h)",
          "type": "bargauge",
          "targets": [
            {
              "expr": "topk(10, sum by (namespace) (rate(kepler_container_joules_total[1h])) / 3600)",
              "legendFormat": "{{namespace}}"
            }
          ]
        }
      ]
    }

# .github/workflows/carbon-aware-build.yml
# Build carbon-aware: verifica carbon intensity prima di eseguire

name: Carbon-Aware Build Pipeline

on:
  push:
    branches: [main, develop, 'feature/**']
  workflow_dispatch:
    inputs:
      force_run:
        description: 'Forza esecuzione ignorando carbon intensity'
        type: boolean
        default: false

jobs:
  # Job 1: Verifica carbon intensity e decide se eseguire ora o schedulare
  carbon-check:
    runs-on: ubuntu-latest
    outputs:
      should_run_now: ${{ steps.check.outputs.should_run_now }}
      carbon_intensity: ${{ steps.check.outputs.carbon_intensity }}
      next_green_window: ${{ steps.check.outputs.next_green_window }}
    steps:
      - name: Check Carbon Intensity
        id: check
        run: |
          # Forza esecuzione su main o se force_run=true
          if [[ "${{ github.ref }}" == "refs/heads/main" ]] || \
             [[ "${{ inputs.force_run }}" == "true" ]]; then
            echo "should_run_now=true" >> $GITHUB_OUTPUT
            echo "carbon_intensity=forced" >> $GITHUB_OUTPUT
            exit 0
          fi

          # Interroga Carbon Aware SDK (self-hosted o public endpoint)
          CARBON_SDK_URL="${{ secrets.CARBON_AWARE_SDK_URL }}"
          LOCATION="${{ vars.GRID_LOCATION }:-DE}"  # Germania di default
          THRESHOLD=150  # gCO2/kWh soglia accettabile

          INTENSITY=$(curl -sf \
            "${CARBON_SDK_URL}/emissions/bylocation?location=${LOCATION}" \
            | jq '.[0].rating // 999' 2>/dev/null || echo "999")

          echo "carbon_intensity=${INTENSITY}" >> $GITHUB_OUTPUT

          if (( $(echo "${INTENSITY} < ${THRESHOLD}" | bc -l) )); then
            echo "Carbon intensity ${INTENSITY} gCO2/kWh - sotto soglia ${THRESHOLD}, eseguo ora"
            echo "should_run_now=true" >> $GITHUB_OUTPUT
          else
            echo "Carbon intensity ${INTENSITY} gCO2/kWh - sopra soglia, cerco finestra verde"
            NEXT_WINDOW=$(curl -sf \
              "${CARBON_SDK_URL}/emissions/forecasts/best?location=${LOCATION}&windowSize=60" \
              | jq -r '.[0].optimalDataPoints[0].timestamp // empty' 2>/dev/null)
            echo "should_run_now=false" >> $GITHUB_OUTPUT
            echo "next_green_window=${NEXT_WINDOW}" >> $GITHUB_OUTPUT
          fi

      - name: Annotate with Carbon Data
        if: always()
        run: |
          echo "::notice::Carbon Intensity: ${{ steps.check.outputs.carbon_intensity }} gCO2/kWh"
          echo "::notice::Prossima finestra verde: ${{ steps.check.outputs.next_green_window }}"

  # Job 2: Build (eseguita solo se carbon intensity e bassa)
  build:
    needs: carbon-check
    if: needs.carbon-check.outputs.should_run_now == 'true'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - name: Install dependencies
        run: npm ci
      - name: Build
        run: npm run build
        env:
          NODE_ENV: production
      - name: Test
        run: npm test -- --coverage
      - name: Carbon annotation
        run: |
          echo "::notice::Build eseguita con carbon intensity: ${{ needs.carbon-check.outputs.carbon_intensity }} gCO2/kWh"

# Step da aggiungere alla fine di ogni workflow
- name: Estimate CI Carbon Footprint
  run: |
    # Stima durata job in minuti (GitHub fornisce start time)
    START_TIME="${{ steps.start-time.outputs.time }}"
    END_TIME=$(date -u +%s)
    DURATION_MINUTES=$(( (END_TIME - START_TIME) / 60 ))

    # Runner ubuntu-latest: ~0.15 kWh/ora (stima conservativa)
    RUNNER_POWER_KWH_PER_HOUR=0.15
    ENERGY_KWH=$(echo "scale=6; $DURATION_MINUTES / 60 * $RUNNER_POWER_KWH_PER_HOUR" | bc)

    # Carbon intensity: usa il valore del carbon-check job
    CARBON_INTENSITY="${{ needs.carbon-check.outputs.carbon_intensity }}"
    CO2_G=$(echo "scale=2; $ENERGY_KWH * $CARBON_INTENSITY" | bc 2>/dev/null || echo "N/A")

    echo "=== GreenOps CI Report ==="
    echo "Durata build: ${DURATION_MINUTES} min"
    echo "Energia stimata: ${ENERGY_KWH} kWh"
    echo "Carbon intensity: ${CARBON_INTENSITY} gCO2/kWh"
    echo "Emissioni stimate: ${CO2_G} gCO2e"
    echo "========================="

    # Scrivi su GitHub Step Summary per visibilità nel report
    echo "## GreenOps CI Report" >> $GITHUB_STEP_SUMMARY
    echo "| Metrica | Valore |" >> $GITHUB_STEP_SUMMARY
    echo "|---------|--------|" >> $GITHUB_STEP_SUMMARY
    echo "| Durata | ${DURATION_MINUTES} min |" >> $GITHUB_STEP_SUMMARY
    echo "| Energia | ${ENERGY_KWH} kWh |" >> $GITHUB_STEP_SUMMARY
    echo "| Carbon Intensity | ${CARBON_INTENSITY} gCO2/kWh |" >> $GITHUB_STEP_SUMMARY
    echo "| Emissioni | ${CO2_G} gCO2e |" >> $GITHUB_STEP_SUMMARY

# Esempio query PromQL per dashboard costo+carbonio unificato
# Assume Kubecost + Kepler + carbon_intensity_g_co2_kwh (da ConfigMap exporter)

# Costo + CO2e per namespace (ultimi 30 giorni)
# Kubecost espone: kubecost_cluster_hourly_cost_by_namespace
# Kepler espone: kepler_container_joules_total

# Costo giornaliero per namespace (USD)
sum by (namespace) (
  kubecost_cluster_hourly_cost_by_namespace * 24
)

# CO2e giornaliero per namespace (kgCO2e)
sum by (namespace) (
  increase(kepler_container_joules_total[24h])
) / 3600000   # Joule -> kWh
* on() group_left() (carbon_intensity_g_co2_kwh / 1000)  # -> kgCO2e

# "Green Efficiency Score" per namespace
# Combina efficienza costo e efficienza carbonica (più alto e meglio)
(
  sum by (namespace) (rate(http_requests_total[1h]))  # throughput
)
/
(
  sum by (namespace) (kubecost_cluster_hourly_cost_by_namespace)  # costo
  *
  (sum by (namespace) (rate(kepler_container_joules_total[1h])) / 3600)  # energia kW
  * on() group_left() carbon_intensity_g_co2_kwh
)

# FASE 1 - Settimane 1-4: Visibility
# Obiettivo: rendere visibili le emissioni, nessuna modifica ai workload

# 1.1 Deploy Kepler DaemonSet
helm install kepler oci://quay.io/sustainable_computing_io/charts/kepler \
  --namespace kepler --create-namespace

# 1.2 Configura ServiceMonitor per Prometheus
kubectl apply -f kepler-service-monitor.yaml

# 1.3 Import dashboard Grafana ufficiale Kepler
# Dashboard ID: 16117 (Kepler Exporter Grafana Dashboard)

# 1.4 Deploy carbon intensity exporter
kubectl apply -f carbon-intensity-exporter.yaml

# Risultato dopo 2 settimane di osservazione:
# - 12 namespace identificati, 3 consumano 78% dell'energia
# - Pipeline ETL notturna: 8.2 kW per 4 ore ogni notte
# - 35 nodi idle dalle 22:00 alle 07:00 (weekdays), tutto il weekend

# ============================================================

# FASE 2 - Settimane 5-8: Quick Wins
# Obiettivo: implementare ottimizzazioni immediate

# 2.1 Cluster Autoscaler + Karpenter per nodi dinamici
helm upgrade --install karpenter oci://public.ecr.aws/karpenter/karpenter \
  --namespace kube-system \
  --set settings.aws.clusterName=production-cluster

# NodePool ottimizzato GreenOps
cat <<EOF | kubectl apply -f -
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: greenops-batch
spec:
  template:
    spec:
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["spot"]  # Spot instances: 70% risparmio
        - key: kubernetes.io/arch
          operator: In
          values: ["arm64"]  # Graviton3: 40% più efficiente di x86
      nodeClassRef:
        group: karpenter.k8s.aws
        kind: EC2NodeClass
        name: graviton-nodes
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 30s  # Rimuovi nodi idle rapidamente
EOF

# 2.2 Namespace sleep per ambienti non-prod (kube-green)
helm install kube-green kube-green/kube-green --namespace kube-green --create-namespace

cat <<EOF | kubectl apply -f -
apiVersion: kube-green.com/v1alpha1
kind: SleepInfo
metadata:
  name: staging-nighttime-sleep
  namespace: staging
spec:
  weekdays: "1-5"  # Lunedi-Venerdi
  sleepAt: "20:00"
  wakeUpAt: "08:00"
  timeZone: "Europe/Rome"
  suspendCronJobs: true
EOF

# Risparmio stimato: 12 ore/giorno x 5 giorni x 8 nodi staging = 480 nodo-ore/settimana

# ============================================================

# FASE 3 - Settimane 9-12: Carbon-Aware Scheduling
# Obiettivo: spostare batch jobs nelle finestre verdi

# 3.1 Deploy Carbon Aware KEDA Operator
kubectl apply -f https://github.com/Azure/carbon-aware-keda-operator/releases/latest/download/operator.yaml

# 3.2 Configura CarbonAwareKedaScaler per pipeline ETL
kubectl apply -f carbon-aware-etl-scaler.yaml

# 3.3 Carbon-aware scheduler per training jobs
# (Python controller dal Paragrafo 3 - eseguito come CronJob ogni ora)
kubectl apply -f carbon-aware-scheduler-cronjob.yaml

# carbon-slo.yaml
# Carbon SLO implementato come PrometheusRule

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: carbon-slo-rules
  namespace: monitoring
spec:
  groups:
    - name: carbon.slo
      interval: 5m
      rules:
        # SLO: namespace "ml-training" deve stare sotto 50 kgCO2e/giorno
        - alert: CarbonSLOViolation_MLTraining
          expr: |
            sum(
              increase(kepler_container_joules_total[24h])
            ) by (namespace) / 3600000
            * on() group_left() (carbon_intensity_g_co2_kwh / 1000)
            > 50
          for: 1h
          labels:
            severity: warning
            greenops: "true"
          annotations:
            summary: "Carbon SLO violato: namespace ml-training"
            description: |
              Il namespace ml-training ha emesso {{ $value | printf "%.1f" }} kgCO2e oggi,
              sopra il SLO di 50 kgCO2e/giorno.
              Carbon intensity corrente: {{ with query "carbon_intensity_g_co2_kwh" }}{{ . | first | value }}{{ end }} gCO2/kWh

        # Trend: emissioni cluster in crescita per 3 giorni consecutivi
        - alert: CarbonTrendIncrease
          expr: |
            (
              sum(rate(kepler_node_package_joules_total[24h]))
              -
              sum(rate(kepler_node_package_joules_total[24h] offset 72h))
            )
            / sum(rate(kepler_node_package_joules_total[24h] offset 72h)) > 0.15
          for: 6h
          labels:
            severity: info
            greenops: "true"
          annotations:
            summary: "Trend emissioni cluster in aumento"
            description: "Emissioni cluster aumentate del {{ $value | humanizePercentage }} nelle ultime 72 ore"