GreenOps: Kubernetes ile Karbon Bilinçli Altyapı
Bugün dünyadaki veri merkezleri arasında tüketimKüresel elektriğin %1 ve %2'si, ile CO₂ eşdeğeri emisyonların yılda 100 ila 200 milyon ton arasında olduğu tahmin ediliyor; bu da tüm dünyadan daha fazla havacılık endüstrisi. Üretken yapay zekaya olan ilgiyle birlikte GPT-4 gibi eğitim modelleri enerji tüketiyor tek seferde yüzlerce transatlantik uçuşa eşdeğerdir. Ancak altyapının çoğu bulut, sanki bu emisyonlar yokmuş gibi çalışmaya devam ediyor: Kubernetes kümeleri döngüler halinde çalışıyor Elektrik şebekesinin karbon yoğunluğuna bakılmaksızın sürekli olarak CI/CD boru hatları elektriğin ne zaman daha temiz olduğunu düşünmeden hemen tetikleniyor ve ekipler DevOps maliyetleri ve gecikmeyi izler ancak kapsül başına emisyonları nadiren izler.
GreenOps bu paradigmayı değiştiren operasyonel disiplindir. Borçlanma metodolojileri Bulut harcamalarını optimize etme uygulaması olan FinOps'tan GreenOps sürdürülebilirlik getiriyor Altyapı kararlarının merkezinde çevre: iş yüklerinin nasıl tahsis edileceği, toplu işlerin ne zaman çalıştırılacağı, hangi bölgede konuşlandırılacağı, düğümlerin nasıl boyutlandırılacağı. Sonuç yalnızca çevresel değildir: GreenOps'u benimseyen kuruluşlar ortalama olarak Emisyonlarda %30-60 azalma bulutla ilgili Enerji verimliliği ve verimliliği sayesinde %15-30 oranında maliyet tasarrufu ekonomik çoğu zaman örtüşür.
Bu makalede sıfırdan başlayarak gerçek anlamda karbon bilinçli bir Kubernetes altyapısı oluşturacağız: kümeyi şununla donatacağız: Kepler kapsül başına güç tüketimini ölçmek için, biz yapılandıracağız Karbon bilincine sahip KEDA operatörü iş yüklerini yoğunluğa göre ölçeklendirmek karbonu gerçek zamanlı olarak uygulayacağız çok bölgeli karbon yönlendirme Karmada ile ve için en yeşil zaman penceresini otomatik olarak seçen bir CI/CD hattı oluşturacağız. yapıları çalıştırın. Her bölüm üretime hazır YAML ve Python kodunu içerir.
Ne Öğreneceksiniz
- GreenOps ile FinOps arasındaki farklar ve bulut sürdürülebilirliği açısından birbirlerini nasıl tamamladıkları
- KEDA ve Azure'un Karbon Bilinçli KEDA Operatörü ile karbon farkındalığına sahip otomatik ölçeklendirme
- Kepler (Kubernetes tabanlı Efficient Power Level Exporter) nasıl kurulur ve yapılandırılır
- Kepler Prometheus ölçümleri: Konteyner, kapsül ve düğüm başına enerji tüketimi
- Karbon yoğunluğuna dayalı CronJob ve PriorityClass ile karbona duyarlı planlama
- Karmada ile çok bölgeli karbon yönlendirme: iş yüklerini daha yeşil bölgelere taşıyın
- Bulut sağlayıcılarının karbon ayak izi API'leri: AWS, Google Cloud, Azure karşılaştırıldı
- Kubernetes kümesi emisyonlarını izlemek için Grafana kontrol paneli
- Yeşil CI/CD: Akıllı derleme planlamayla karbona duyarlı GitHub Eylemleri
- Örnek olay: 3 ayda emisyonlarda %35 azalma sağlayan 50 düğüm kümesi
Yeşil Yazılım Mühendisliği Serisi — Tüm Makaleler
| # | Başlık | Ders |
|---|---|---|
| 1 | Yeşil Yazılım Mühendisliğinin İlkeleri | 8 GSF ilkeleri, SCI spesifikasyonu ISO/IEC 21031 |
| 2 | CodeCarbon ile Emisyonların Ölçülmesi | Python, MLflow, kontrol panelinde CO₂ takibi |
| 3 | Climatiq API: Bulut Sistemlerinde Karbon Yoğunluğu | REST API, bulut emisyon hesaplaması ve tedarik zinciri |
| 4 | Carbon Aware SDK: Zaman ve Konum Değiştirme | GSF SDK, WattTime, ElectricityMaps, Kubernetes, CI/CD |
| 5 | Kapsam 3 ve ÇSY Boru Hattı | Yukarı/aşağı yönde emisyonlar, CSRD veri hattı |
| 6 | GreenOps: Kubernetes ile Karbon Bilinçli Altyapı (bu makale) | KEDA karbon ölçekleyici, Kepler, çok bölgeli yönlendirme, Yeşil CI/CD |
| 7 | Kapsam 1, 2, 3 modelleme | Sera Gazı Protokolü muhasebe çerçeveleri, SBTi |
| 8 | Yapay Zeka Karbon Ayak İzi | Yüksek Lisans eğitimi, çıkarım, enerji optimizasyonu |
| 9 | Sürdürülebilir Yazılım Kalıpları | Yeşil desen tasarımı, verimli mimariler |
| 10 | Yazılım için ESG ve CSRD | Mevzuata uygunluk, zorunlu AB raporlaması |
GreenOps vs FinOps: Alternatif Değil, Tamamlayıcı
FinOps, bulut harcamalarındaki kontrolsüz artışa bir yanıt olarak doğdu: maliyetler hesaba katılmadan kaynaklar, aylarca aktif olan unutulmuş EC2 bulut sunucuları, optimize edilmemiş depolama değer üretmeden biriktirilen faturalar. FinOps gerçekleştirilecek kültürü, süreçleri ve araçları getiriyor Görünür harcamaları yönetin ve sistematik olarak optimize edin. GreenOps açıkça bu modelden ilham alıyor bunu karbon emisyonlarına uygulamak: emisyonları iş yüküne göre görünür hale getirir, süreçleri başlatır optimizasyonu sağlar ve ekiplerde sorumluluk yaratır.
İyi haber şu ki iki disiplin büyük ölçüde örtüşüyor: aynı kapsül Aşırı boyut hem para hem de enerji israfına neden olur. Boşta kalan bir küme bir gecede her iki bütçeyi de yakar bu CO₂. Optimize etmek çoğu zaman her ikisini de optimize etmek anlamına gelir. Ama aynı zamanda önemli farklılıklar da var anlamak.
GreenOps ve FinOps: Karşılaştırma Tablosu
| Boyut | FinOps | GreenOps | Entegrasyon |
|---|---|---|---|
| Birincil amaç | Bulut harcamalarını azaltın, yatırım getirisini optimize edin | CO₂ emisyonlarını azaltın, enerji verimliliğini artırın | Çoğunlukla aynı doğrultudadır: verimlilik = tasarruf = emisyon azaltımı |
| Temel metrik | İş birimi başına maliyet ($/istek, $/kullanıcı) | İş birimi başına gCO₂eq (Karbon Yoğunluğu) | Entegre kararlar için ortak maliyet+karbon gösterge tabloları |
| Ana kol | Doğru boyutlandırma, ayrılmış örnekler, spot fiyatlandırma | Zaman kaydırma, konum değiştirme, talep şekillendirme | Zaman kaydırma hem maliyet artışlarını hem de emisyonları azaltır |
| Parçalılık | Etiket bulutu, ekip, hizmet, hesap | Pod, konteyner, sunucusuz işlev | Kepler, GreenOps ayrıntı düzeyini FinOps gibi kapsül düzeyine getiriyor |
| Geçicilik | Aylık/Üç Aylık Optimizasyon (Fatura) | Saatlik optimizasyon (karbon yoğunluğu değişkenliği) | GreenOps, gerçek zamanlı otomasyon gerektirir; Daha statik FinOps |
| Olası çatışmalar | Spot örnekler daha ucuzdur ancak bölgede karbon yoğunluğu yüksektir | Bölge yeşil ancak daha pahalı, daha yüksek gecikme süresi | Maliyet+karbon puanlamasının birleşimiyle açık tavizler |
| Aletler | AWS Maliyet Gezgini, CloudHealth, Kubecost | Kepler, Carbon Aware SDK, bulut karbon API'leri | Kubecost + Kepler: aynı kontrol panelinde kapsül başına maliyet ve karbon |
| Standart | FinOps Vakfı FOCUS spesifikasyonu | GSF SCI Spesifikasyonu, Sera Gazı Protokolü | Birleştirilmiş ölçümlerle 2026'da yakınlaşma bekleniyor |
FinOps ve GreenOps arasındaki en stratejik yakınlaşma noktası doğru boyutlandırma: Pod'ların aşırı CPU/bellek taleplerini azaltmak yalnızca bulut faturanızı düşürmekle kalmaz, aynı zamanda doğrudan azaltır Yükle orantılı olarak ölçeklenen düğümlerin enerji tüketimi. Satın alma sonrası CloudBolt verilerine göre StormForge (Mart 2025) tarafından, yapay zeka odaklı doğru boyutlandırmayla optimize edilen kümelerde ortalama azalma görüldü hem maliyetlerde hem de emisyonlarda %40 oranında artış; hiçbir ödünün olmadığı nadir bir durum.
Bunun yerine çatışma, düşük karbon yoğunluğuna sahip bir bulut bölgesinin coğrafi olarak konumlandırılması durumunda ortaya çıkar. uzakta ve bu nedenle veri aktarımı için daha pahalı veya ucuz bir nokta örneği olduğunda ağırlıklı olarak kömürle beslenen bir bölgede yer almaktadır. Bu senaryolarda GreenOps ekipleri daha fazla olgun yetişkinler birini evlat edinir bileşik puanlama fonksiyonu Maliyeti, emisyonları ve gecikmeyi dengeleyen Farklı iş yükü türleri için yapılandırılabilir ağırlıklarla.
Karbona Duyarlı Kubernetes: KEDA ve Karbona Duyarlı Operatör
KEDA (Kubernetes Olay Odaklı Otomatik Ölçekleyici), aşağıdakileri sağlayan açık kaynaklı Kubernetes bileşenidir: iş yüklerini olaylara ve harici ölçümlere (mesaj kuyrukları, Prometheus ölçümleri, HTTP uç noktaları. Karbon Bilinçli KEDA OperatörüMicrosoft Azure tarafından geliştirilmiş ve yayınlanmıştır. GitHub'da KEDA'yı tamamen yeni bir boyutla genişletiyor: elektrik şebekesinin karbon yoğunluğu yerel. Sonuç, ölçeklenen bir kümedir aşağı doğru elektrik ne zaman Fosil kaynaklardan üretilen, e yukarı Yenilenebilir enerjinin bol olduğu zamanlar.
Mekanizma sadeliğiyle zariftir. Operatör mevcut karbon yoğunluğunu okur — WattTime, ElectricityMaps veya başka herhangi bir kaynaktan gelir ve kümedeki bir ConfigMap'i bir değer her saat başı güncellenir. KEDA ScaledObject, ConfigMap'i okur ve değeri girdi olarak kullanır. izin verilen maksimum çoğaltma sayısını belirleyin: yoğunluk yüksek olduğunda (ağ karbon yoğun), tavan düşüyor; yoğunluk düşük olduğunda (temiz enerji), tavan yükselir ve küme daha agresif bir şekilde ölçeklenebilir.
Karbon Bilinçli KEDA Operatör Mimarisi
# 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
Dağıtımın gerçek otomatik ölçeklendirmesini yöneten ilgili KEDA ScaledObject:
# 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"
Karbon Yoğunluğu ConfigMap Aktarıcı
Karbon yoğunluğu verilerini içeren ConfigMap'in harici API'leri sorgulayan bir iş tarafından doldurulması gerekir.
proje kubernetes-carbon-intensity-exporter Azure şu bileşeni sağlar:
# 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
Karbon Bilinçli Ölçeklendirmeye Uygun İş Yükleri
Karbona duyarlı ölçeklendirme yalnızca iş yükleri için işe yarar ertelenebilir o elastik:
toplu işler, makine öğrenimi eğitimi, ETL hattı, rapor işleme, medya kod dönüştürme. Hizmetlere uygulamayın
Gecikmenin kritik olduğu gerçek zamanlı kullanıcıya yönelik (API ağ geçidi, ön uç). Parametre
minReplicaCount yüksek karbon yoğunluğu koşullarında bile bölmelerin minimum düzeyde olmasını garanti eder
Hizmetin kullanılabilirliğini korumak için rotasyona devam edin.
Karbon Bilinçli Planlama: CronJob ve PriorityClass Verdi
GreenOps, reaktif otomatik ölçeklendirmenin yanı sıra planlamayı da sunuyor proaktif: bunun yerine Mevcut karbon yoğunluğuna tepki olarak, en yeşil zaman penceresinin önümüzdeki dönemde gerçekleşmesi bekleniyor. sonraki 24 saati belirler ve işi o saatte çalışacak şekilde planlar. WattTime ve ElectricityMaps'in sunduğu özellikler 72 saate kadar tahminler yaparak bu optimizasyonu mümkün kılar.
Karbon Bilinçli CronJob için Python Denetleyicisi
Carbon Aware SDK'yı sorgulayan ve takvimi dinamik olarak yeniden yazan hafif bir Python denetleyicisi Kubernetes CronJob'un yeşil pencereyi işaret etmesi için:
#!/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")
PriorityClass Karbon Farkındalığı
Kubernetes, pod'lara öncelik vermenizi sağlar PriorityClass. Bir bağlamda
GreenOps, erteleme toleransını yansıtan öncelik sınıflarını tanımlarız: iş yükleri
kritik olanlar yüksek önceliklidir, ertelenemeyenler ise düşük öncelikli olarak programlanır
ve kaynakların birden fazla işe yoğunlaştırılması gerektiğinde tahliye edilebilir veya ertelenebilir
Düşük karbon yoğunluklu pencereler sırasında acil.
# 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"
Karmada ile Çok Bölgeli Karbon Yönlendirme
Zaman kaydırma iş yükünü zaman aynı bölgede. konum değiştirme daha da ileri gider: iş yükünü uzayişi karbonla bulut bölgesinde yürütmek o andaki en düşük yoğunluk. Coğrafi değişkenlik muazzamdır: belirli bir anda, eu-north-1 (Stockholm, neredeyse tamamen hidroelektrikle çalışıyor) 15 gCO₂/kWh yoğunluğa sahipken, us-doğu-1 (Virginia, kömür/gaz/nükleer karışımıyla) 300-400 gCO₂/kWh olabilir. İsveç'e makine öğrenimi eğitimi işi getirmek yerine Virginia emisyonları azaltıyor Aynı hesaplamayla %90+.
Karmada (Kubernetes Armada) küme yönetimine yönelik CNCF projesidir Çoklu Kubernetes. İş yüklerini birden çok bölgedeki birden çok kümeye dağıtmanıza olanak tanır. sofistike politikalar Gerçek zamanlı karbon yoğunluğu verileriyle birleştirildiğinde, çok bölgeli karbon yönlendirme
Çok Bölgeli GreenOps Mimarisi
# 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
Carbon Router: Karmada Politikalarının Dinamik Güncellemesi
#!/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)
Bulut Sağlayıcı Karbon API'leri: AWS, Google Cloud, Azure
Açık kaynak araçlarına paralel olarak üç büyük bulut sağlayıcısı, önemli ölçüde yerel karbon ayak izi araçları. 2025 yılında durum çok olgunluk ve kullanılabilirlik açısından çeşitlendirilmiştir.
Karbon Ayak İzi Bulut Sağlayıcısı API Karşılaştırması (2025)
| Sağlayıcılar | Enstrüman | Parçalılık | API'mi? | Süpürgeler | Güncelleme |
|---|---|---|---|---|---|
| AWS | Müşteri Karbon Ayak İzi Aracı | Hesap, Bölge, Hizmet | Yalnızca CSV dışa aktarımı | Kapsam 1, 2, 3 (2024'ten itibaren) | Aylık (3 ay gecikmeli) |
| Google Bulut | Bulut Karbon Ayak İzi | Proje, Hizmet, Bölge | BigQuery dışa aktarma + API | Kapsam 1, 2, 3 | Aylık (4 hafta gecikmeli) |
| Azure | Microsoft Emisyon Etki Kontrol Paneli / Karbon Optimizasyonu | Abonelik, Kaynak Grubu, Hizmet | REST API'yi tamamlayın (2025) | Kapsam 1, 2, 3 | Aylık (2 ay gecikmeli) |
| Çoklu bulut | Bulut Karbon Ayak İzi (açık kaynak) | Hesap, Hizmet, Bölge | Kendi kendine barındırılan REST API | Kapsam 2 (kendi metodolojisi) | Günlük |
Azure Karbon Optimizasyonu REST API'si
Microsoft, 2025 yılının en önemli adımını lansmanıyla attı Karbon Optimizasyon Azure portalında, entegrasyon için eksiksiz bir REST API tarafından desteklenir iç sistemler. Entegrasyon örneği:
#!/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")
Karbon Verileri için Önerilen Strateji
- Gerçek zamanlı planlama: Kararlar için Carbon Aware SDK + WattTime/ElectricityMaps'i kullanın Karbon farkındalığına dayalı planlamayla gerçek zamanlı
- Aylık raporlama: Muhasebe için bulut sağlayıcının yerel araçlarını kullanın CSRD/ESG raporlaması için resmi CO₂ (Kapsam 1/2/3) gereklidir
- Çoklu bulut: Birden fazla kaynaktan veri toplamak için açık kaynak Bulut Karbon Ayak İzini kullanın sağlayıcı sürekli
- Operasyonel uyarılar: Tüketim ani artışlarıyla ilgili gerçek zamanlı uyarılar için Kepler + Prometheus'u kullanın kapsül başına enerji
Kepler: Kapsül Başına Enerji Tüketimini Ölçme
Kepler (Kubernetes tabanlı Efficient Power Level Exporter) bir CNCF projesidir Kubernetes kümesindeki konteyner, kapsül ve düğüm düzeyinde enerji tüketimini ölçen ve dışa aktaran Prometheus'a ait ölçümler. Emisyonları görünür kılmanın temel bileşenidir operasyonel seviye: Kepler olmadan DevOps ekibi iş yükü başına emisyonlara karşı kördür ve bunu yapamaz. GreenOps'u etkili bir şekilde gerçekleştirin.
Kepler, kaynak tüketimini izlemek için genişletilmiş Berkeley Paket Filtresi (eBPF) yaklaşımını kullanıyor çekirdek düzeyinde donanım, verileri birleştiriyor RAPL (Çalışan Ortalama Güç Sınırı, arayüz CPU tüketimi için Intel/AMD), ACPI sistem tüketimi ve sensörler için NVIDIA NVML'si GPU'lar için. Fiziksel donanım sensörlerinin bulunmadığı bulut sağlayıcılarında erişilebilir olduğundan Kepler, mevcut CPU ölçümlerine dayalı tahmin modellerini kullanır.
0.10.0 (2025) sürümünden itibaren Kepler, mimari olarak tamamen yeniden yazıldı bulut VM'lerindeki tahminlerin doğruluğunu artıran ve DaemonSet'in yükünü yaklaşık olarak azaltan dahili %5 ila %2'den az CPU.
Helm ile Kepler kurulumu
# 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{...}
Ana Kepler Metrikleri
GreenOps için Temel Kepler Metrikleri
| Metrik | Tanım | Birim | Kullanım örneği |
|---|---|---|---|
kepler_container_joules_total |
Başlangıçtan bu yana konteyner tarafından tüketilen toplam enerji | Joule (sayaç) | Zaman içinde kapsül başına enerji |
kepler_container_cpu_joules_total |
Kapsayıcı için CPU tarafından tüketilen enerji | Joule (sayaç) | Yüksek güçlü CPU'ya bağlı iş yüklerini belirleyin |
kepler_container_dram_joules_total |
Kap için RAM tarafından tüketilen enerji | Joule (sayaç) | Belleğe bağlı iş yükü analizi |
kepler_container_gpu_joules_total |
Tüketilen GPU gücü (NVIDIA gerektirir) | Joule (sayaç) | ML eğitimi tüketimi takibi |
kepler_node_core_joules_total |
CPU çekirdeği başına toplam düğüm enerjisi | Joule (sayaç) | Düğüm verimliliği, tüketim temel çizgisi |
kepler_node_package_joules_total |
Toplam CPU paketi enerjisi (tüm çekirdekler) | Joule (sayaç) | PUE hesaplaması, toplam düğüm tüketimi |
kepler_container_watts |
Anında konteyner gücü | Watt (gösterge) | Enerji artışlarında gerçek zamanlı uyarılar |
GreenOps için PromQL sorguları
# 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
GreenOps için Grafana Kontrol Paneli
Kepler projesi, doğrudan içe aktarılabilen önceden oluşturulmuş Grafana kontrol panelleri sağlar. Yapılandırma entegre bir görünüm oluşturmak için Kepler ölçümlerini karbon yoğunluğu verileriyle birleştirmeniz önerilir:
# 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}}"
}
]
}
]
}
Yeşil CI/CD: GitHub Eylemleri Karbon Farkındalığı
CI/CD işlem hatları, karbon bilinçli planlama için ideal adaylardır: tetikleyen bir yapı her itmenin mutlaka yürütülmesi gerekmez hemen. Özellik dalı yapıları, i kapsamlı regresyon testleri, yapı oluşturma, hazırlama ortamlarına dağıtımlar - hepsi genellikle saatlerce süren ölçülebilir bir gecikme toleransına sahiptirler. Bu işlem hatlarını pencerelere taşıyın Düşük karbon yoğunluğu çok az çaba gerektirir ve CI/CD emisyonlarını azaltabilir %20-40.
Karbon Bilinçli Planlama ile GitHub Eylemleri
# .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"
CI/CD Emisyonlarını Tahmin Edin
Yapıları yeşil pencerelere taşımanın yanı sıra, gerçek emisyonların ölçülmesi de faydalıdır. CI/CD boru hattı. GitHub tarafından barındırılan koşucular, üretim saatine bağlı olarak yaklaşık 0,05-0,2 kWh tüketir. koşucu Tür. Emisyonları tahmin etmek ve günlüğe kaydetmek için bir eylem adımını burada bulabilirsiniz:
# 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
FinOps + GreenOps Kontrol Paneli: Maliyet ve Karbon Bir Arada
Bir kuruluşun GreenOps olgunluğu aynı zamanda ilişkilendirme yeteneğiyle de ölçülür. maliyet ve emisyon ölçümleri tek bir görünümde. Bu boyutları ayrı ayrı yöneten ekipler optimal olmayan kararlar veriyorlar: maliyeti %20 oranında azaltan doğru düzenlemenin hiçbir etkisi olmayabilir tasarrufların karbon yoğun bölgelerdeki örneklere yeniden yatırılması durumunda emisyonlarla ilgili. Tam tersine, Konumun daha yeşil bölgeye kaydırılması, yer değiştirme maliyetlerini artırabilir ekonomik faydayı ortadan kaldıran veriler.
İdeal entegrasyon birleştirir Kubecost (kapsül/ad alanı başına maliyet) ile Kepler (pod/ad alanı başına enerji), karbon yoğunluğu verileriyle zenginleştirilmiş tek bir Grafana kontrol panelinde Her iş yükünün gerçek karbon maliyetini hesaplamak için gerçek zamanlı olarak.
# 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
)
İzlenecek Temel GreenOps KPI'ları
- Mevcut Karbon Yoğunluğu (gCO₂/kWh): elektrik şebekesinden gerçek zamanlı veriler
- kgCO₂e/saat kümesi: kümenin toplam emisyonları
- kWh/talep: iş birimi başına enerji verimliliği
- gCO₂e/talep: iş birimine göre karbon ayak izi
- Yeşil pencerelerdeki iş yükü yüzdesi: CI < eşiğiyle yürütülen toplu işlerin yüzdesi
- Maliyet/kgCO₂ kaçınıldı: GreenOps girişimlerinin yatırım getirisi
- Tahmini PUE: Kümenin Güç Kullanımı Etkinliği (hedef < 1,2)
- Boşta enerji israfı: Az kullanılan bölmeler/düğümler tarafından tüketilen enerji
Örnek Olay: 50 Düğüm Kümesinde Emisyonların %35 Azaltılması
Aşağıdaki örnek olay, kümeye sahip bir Avrupa SaaS şirketinin gerçek dünya sonuçlarını özetlemektedir 50 düğümden oluşan üretim Kubernet'leri (AWS us-east-1'de c5.4xlarge ve m5.2xlarge karışımı), veri analizi ardışık düzenlerini, makine öğrenimi modeli eğitimini ve arka uç API'lerini yöneten.
İlk Küme Profili (Temel)
| Metrik | Temel değer | GreenOps sonrası değer (3 ay) | Kesinti |
|---|---|---|---|
| CO₂e emisyonları/ay | 12,4 tCO₂e | 8.1 tCO₂e | -35% |
| Bulut maliyeti/ay | 47.200$ | 38.900$ | -%17,6 |
| Ortalama CPU kullanımı | %23 | %41 | +%78 (verimlilik) |
| Boşta kalan düğümler (gece) | 50 üzerinden 35 knot | 50 düğümden 8'i (minimum küme) | -%78 boşta kalan düğümler |
| Yeşil pencerelerdeki toplu işlerin yüzdesi | %0 (ölçülmemiş) | %68 | +68pp |
| kgCO₂e/1000 API istekleri | 0,84 | 0,55 | -35% |
Kronolojik Sırayla Uygulanan Eylemler
GreenOps programı 12 hafta boyunca üç aşamada uygulandı:
# 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
Sonuçların Analizi
Emisyonlardaki %35'lik azalma çeşitli girişimler arasında aşağıdaki şekilde dağıtıldı:
- Doğru boyutlandırma ve düğüm birleştirme (Karpenter + Graviton3): -%18 emisyon. Graviton3 arm64 bulut sunucularına geçiş, işlem birimi başına güç tüketimini azalttı %40 oranında. Karpenter'in konsolidasyon politikası, yeterince kullanılmayan 27 düğümü ortadan kaldırdı.
- hazırlama/geliştirme ortamları için kube-green: -%9 emisyon. Üretken olmayan ortamlar 7/24 aktiftiler ve çoğunlukla kümenin toplam enerjisinin %22'sini tüketiyorlardı kimsenin onları kullanmadığı saatlerde.
- Karbon bilinçli planlama toplu işleri: -%8 emisyon. Toplu işlerin %68'i artık abd-doğu-1 ağının karbon yoğunluğunun 150 gCO₂/kWh'den düşük olduğu pencerelerde planlanıyor.
Operasyonel açıdan en önemli veriler: Aylık 8.300$ maliyet tasarrufu (-%17,6) GreenOps programının uygulama maliyetini büyük ölçüde karşıladı (yaklaşık 3 hafta) mühendislik) 4 hafta içinde. GreenOps'un iş durumu artık Tamamen çevresel açıdan haklı.
Dikkat: Optimize Etmeden Önce Ölçün
GreenOps'u ilk görünürlük aşaması olmadan uygulayan ekiplerin %40'ı işleri optimize ediyor yanlış. Bu vaka çalışmasında, makine öğrenimi eğitiminin ana tüketici olduğu varsayılmıştır. enerji - bunun yerine, gece ETL boru hatları ve her zaman açık hazırlama ortamları vardı. Kepler 2 haftada gerçek ortaya çıktı Başka bir şey yapmadan önce Kepler'ı konuşlandırın.
GreenOps Anti-Desen: Kaçınılması Gerekenler
Saha deneyimi, GreenOps programlarının faydalarını ortadan kaldıran yinelenen hataları tespit etmiştir Daha da kötüsü, emisyonlarda gerçek bir azalma olmadan sahte bir sürdürülebilirlik duygusu yaratıyorlar.
En Yaygın GreenOps Anti-Desenleri
| Anti-desen | Tanım | Darbe | Çözüm |
|---|---|---|---|
| Azaltma olmadan Karbon Dengeleme | Operasyonel emisyonları azaltmak yerine karbon kredisi satın alın | Gerçek emisyonlar değişmedi, minimum etki | Her zaman Kaçın > Azalt > Dengele'ye öncelik verin (GSF çerçevesi) |
| Ortalama ve Marjinal yoğunluk | Kararlar için marjinal yerine ortalama karbon yoğunluğunu kullanın | Kötü optimizasyonlar: marjinal kaynak eklenen/kaldırılan kaynaktır | WattTime'ın marjinal karbon yoğunluğu verilerini kullanın (abonelik gerektirir) |
| Ölçmeden optimize edin | Kepler temelleri olmadan karbona duyarlı ölçeklendirme uygulayın | Gerçek etkiyi doğrulamak imkansızdır | Optimize etmeden önce Kepler'ı en az 2 hafta temel olarak dağıtın |
| Geri Tepme Etkisini Yoksay | Bir iş yükünde emisyonları azaltın ve diğerinde artırın | Sıfır veya negatif net fayda | Tek iş yükü değil, küme düzeyinde izleme |
| Ertelenemeyen iş yüklerinde karbon farkındalığı | Kullanıcıya yönelik API'lere de karbon tavanı uygulayın | Performans düşüşü, SLA ihlal edildi | Ertelenebilir ve gerçek zamanlı iş yüklerini titizlikle sınıflandırır |
| Yalnızca Kapsam 2 | Yalnızca operasyonel güç tüketimini ölçün, Kapsam 3'ü dikkate almayın | Gerçek ayak izinin önemli ölçüde küçümsenmesi | Donanımın ve veri aktarımının somutlaşmış karbonunu dahil edin |
| İşlem yapılmayan kontrol paneli | Kepler ve Grafana'yı yükleyin ancak karbon SLO'sunu tanımlamayın | Güzel ölçümler, sıfır iyileştirme | İhlal uyarısı içeren her ad alanı için Karbon SLO'sunu tanımlayın |
Karbon SLO: Emisyonlara ilişkin Hizmet Seviyesi Hedefleri
GreenOps'u kurumsallaştırmanın en etkili modeli, Karbon SLO ad alanı/ekip için tam olarak gecikme ve kullanılabilirlik SLO'larının tanımlandığı gibi. Bir Karbon SLO'su Sürdürülebilirliği belirsiz bir hedeften, açık hesap verebilirliğe sahip ölçülebilir bir hedefe dönüştürüyor:
# 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"
GreenOps Yol Haritası: Başlangıçtan Veri Odaklılığa
GreenOps'u benimsemek, her şeyi aynı anda uygulamanızı gerektirmez. Yol aşamalar halinde gelişiyor ilerici, her biri daha fazla yatırım gerektirmeden ölçülebilir değer getiriyor.
GreenOps Olgunluğu: 4 Seviye
| Seviye | İsim | Özellikler | Tipik zaman çizelgesi | Beklenen CO₂ azalması |
|---|---|---|---|---|
| 1 | Görünürlük | Kepler kuruldu, Grafana'da ilk ölçümler yapıldı, Karbon SLO'ları tanımlandı (henüz uygulanmadı) | 2-4 hafta | %0 (yalnızca ölçüm) |
| 2 | Hızlı Kazanımlar | Doğru boyutlandırma, üretim dışı ortamlar için kube yeşili, optimize edilmiş otomatik ölçekleyici kümesi, Graviton/ARM64 | 1-2 ay | %15-25 |
| 3 | Karbon Bilinçli Planlama | KEDA karbon ölçekleyici, karbona duyarlı CronJob planlayıcı, Yeşil CI/CD, Karbon SLO zorunlu | 2-3 ay | %25-40 |
| 4 | Çoklu Bölge Optimizasyonu | Karmada konum değiştirme, karbon optimizasyonlu veri aktarımı yönlendirme, tam Kapsam 3 muhasebesi | 4-6 ay | %35-60 |
Seviye 1 (Görünürlük) en önemli ve çoğu zaman en çok gözden kaçan adımdır. Ölçmediğiniz şeyi optimize edemezsiniz: İki haftalık Kepler verileri ortaya çıkıyor her zaman beklenmedik fırsatlar - unutulmuş ortamlar, döngüler halinde çalışan işler, Gerçek kullanımla eşleşmeyen, şişirilmiş CPU taleplerine sahip ad alanları. Bu keşifler Kepler kurulumuna yapılan yatırımı haklı çıkaracak tek şey bu.
Sonuçlar
GreenOps, yeşil görünmek isteyen şirketler için bir lüks değil: bir disiplindir Doğrudan ve ölçülebilir ekonomik faydalar sağlayan ve yakında Avrupa Birliği'nin CSRD direktifine tabi şirketler için zorunludur. Kapsam 2 emisyonları bulut bilişim (veri merkezleri tarafından tüketilen elektrikten kaynaklanan emisyonlar) bugün bile binlerce Avrupalı şirket için zorunlu bir bildirim öğesi ve ayrıntı düzeyi ESRS çerçevelerinin gerektirdiği işler giderek bireysel iş yükleri düzeyine düşmektedir.
Kubernetes için GreenOps araç seti bugün şaşırtıcı derecede olgunlaştı: Kepler için kapsül başına enerji ölçümü, Karbon Bilinçli KEDA Operatörü ölçeklendirme için karbon bilincine sahip Karbon Bilinçli SDK veriler için Yeşil Yazılım Vakfı'ndan gerçek zamanlı karbon yoğunluğu, Karmada konum değiştirme için çoklu küme. Bu araçların tümü açık kaynaklıdır, aktiftir ve üretimde büyük oranda kullanılmaktadır. kuruluşlar.
Başlangıç noktası her zaman aynıdır: Kepler'i kurun, iki hafta boyunca verilere bakın ve Bırakın gerçeklik öncelikleri yönlendirsin. Deneyimler gösteriyor ki %70 hızlı GreenOps kazanırsa gözlemin ilk 14 gününde tespit edilir. Ve bunun vaka çalışmasında olduğu gibi makale, ekonomik ROI, tüm programın 1-2 ay içinde kendi kendini finanse etmesini sağlar.
Yeşil Yazılım Mühendisliği Serisi devam ediyor
- Önceki makale (5): Kapsam 3 ve ESG Boru Hattı — yukarı yöndeki emisyonlar e aşağı akış, CSRD uyumluluğu için veri hattı
- Sonraki makale (7): Kapsam 1, 2, 3 modelleme – muhasebe çerçeveleri GHG Protokolü, SBTi Net-Zero Standardı, modelleme araçları
- MLOps serisiyle ilgili: Karbonu azaltmak için ML Eğitimini optimize edin ayak izi — niceleme, budama, donanım seçimi
- Veri ve Yapay Zeka İş serisiyle ilgili: Veri Merkezi ve Sürdürülebilirlik — KOBİ'ler için PUE, WUE, yenilenebilir enerji alımı
Kaynaklar ve Referanslar
- GitHub'da Kepler — Kubernetes tabanlı Verimli Güç Seviyesi Aktarıcı
- Karbon Bilinçli KEDA Operatörü — Azure/Microsoft
- Carbon Aware SDK — Yeşil Yazılım Vakfı (MIT Lisansı)
- Kepler Projesi — CNCF Korumalı Alan
- Bulut Karbon Ayak İzi — Açık kaynaklı çoklu bulut aracı
- GreenOps ve FinOps: Sürdürülebilir Yapay Zeka için İkili Strateji — Yeni Yığın
- Yeşil Yazılım Vakfı — SCI Spesifikasyonu ve kaynakları