Ne Aramıştınız?
Makaleler, projeler ve kaynaklar arasında arama yaparak size özel fikirler, bilgiler ve ilham kaynakları keşfedin.
Takip et
Ne Aramıştınız?
Makaleler, projeler ve kaynaklar arasında arama yaparak size özel fikirler, bilgiler ve ilham kaynakları keşfedin.
Takip et
Kategoriler
Son Yazılar

Hetzner Cloud Kaynaklarını AWS CloudWatch ile Terraform Üzerinden İzleme

Hetzner Cloud altyapınızın performansını ve sağlığını AWS CloudWatch’un güçlü izleme yetenekleriyle entegre etmek mi istiyorsunuz? Bu kapsamlı rehberde, Terraform’un gücünü kullanarak Hetzner Cloud sunucularınızdan gelen metrikleri AWS CloudWatch’a nasıl aktaracağınızı, alarmlar kuracağınızı ve dinamik panolar oluşturacağınızı adım adım keşfedeceğiz. Hibrit bulut izleme stratejinizi otomatize edin!

Günümüzün karmaşık IT dünyasında, farklı bulut sağlayıcıları üzerinde çalışan altyapılar yaygın bir durum haline geldi. Maliyet etkinliği, belirli özellik setleri veya coğrafi yakınlık gibi nedenlerle, işletmeler genellikle birden fazla bulut platformunu bir arada kullanmayı tercih eder. Hetzner Cloud, güçlü donanım seçenekleri ve rekabetçi fiyatlandırmasıyla özellikle Avrupa’da popüler bir seçenektir. Ancak, birçok kuruluşun zaten AWS ekosisteminde merkezi bir izleme ve yönetim altyapısı bulunmaktadır. Bu durumda, Hetzner Cloud kaynaklarını AWS CloudWatch gibi tanıdık ve güçlü bir izleme çözümüne entegre etmek, operasyonel verimlilik ve tutarlılık açısından kritik bir ihtiyaç haline gelir.

Peki, bu entegrasyonun sunduğu temel avantajlar nelerdir? İlk olarak, merkezi izleme panoları oluşturmanıza olanak tanır. Farklı platformlardaki kaynaklarınızı tek bir yerden gözlemlemek, IT ekiplerinin “pane of glass” prensibini uygulamasını sağlar. Yani, tüm sistemin genel sağlığını ve performansını tek bir ekrandan görebilirsiniz. Bu, sorun giderme sürelerini kısaltır ve daha proaktif bir yaklaşım benimsemenize yardımcı olur. Örneğin, Hetzner üzerindeki bir sunucunuzun CPU kullanımındaki ani bir artış ile AWS üzerindeki bir Lambda fonksiyonunun hata oranındaki artış arasındaki korelasyonu tek bir panoda görmek, kök neden analizi için paha biçilmez bilgiler sunar.

İkinci olarak, AWS CloudWatch’un gelişmiş alarm mekanizmaları, anomali tespiti ve otomatik bildirim özellikleri, Hetzner kaynaklarınız için de kullanılabilir hale gelir. Hetzner sunucularınızdaki disk doluluğu, bellek tüketimi veya ağ trafiği gibi kritik metrikler belirli eşikleri aştığında, SMS, e-posta, Slack veya PagerDuty gibi kanallar aracılığıyla otomatik olarak uyarılar alabilirsiniz. Bu, operasyonel aksaklıkları hızlıca tespit etmenize ve potansiyel kesintilerin önüne geçmenize yardımcı olur. AWS’nin sunduğu otomasyon yetenekleri sayesinde, bu alarmları tetikleyen olaylara yanıt olarak otomatik düzeltici eylemler bile başlatabilirsiniz; örneğin, bir sunucuyu yeniden başlatmak veya bir otomatik ölçeklendirme grubunu tetiklemek gibi (gerçi Hetzner tarafında bu biraz daha manuel entegrasyon gerektirecektir).

Üçüncü ve belki de en önemli avantajlardan biri, Terraform ile altyapının otomasyonudur. Terraform, “altyapı kod olarak” (Infrastructure as Code – IaC) prensibini benimseyerek, izleme altyapınızın dağıtımını ve yönetimini otomatikleştirmenizi sağlar. Bu, manuel yapılandırma hatalarını en aza indirir, tekrar üretilebilir ortamlar yaratır ve değişikliklerin sürüm kontrolü altında tutulmasını kolaylaştırır. Hetzner ve AWS gibi farklı bulut sağlayıcıları arasında tutarlı bir izleme altyapısı kurmak, Terraform’un sağlayıcı tabanlı mimarisi sayesinde oldukça kolaylaşır. Bu otomasyon, DevOps ekipleri için büyük bir zaman tasarrufu sağlar ve operasyonel yükü azaltır, böylece daha çok inovasyona odaklanabilirler. Bu entegrasyon, hibrit bulut stratejisi izleyen modern işletmeler için vazgeçilmez bir araç setidir.

Temel Kavramlara Hızlı Bir Bakış: Hetzner, CloudWatch ve Terraform

Bu entegrasyonun derinliklerine dalmadan önce, projemizin temel taşlarını oluşturan Hetzner Cloud, AWS CloudWatch ve Terraform hakkında kısa bir özet geçmek faydalı olacaktır. Bu platformların her birinin kendi benzersiz yetenekleri ve kullanım alanları vardır ve bunları birlikte kullanmak, hibrit bulut yönetiminde güçlü bir sinerji yaratır.

Hetzner Cloud Nedir?

Hetzner Cloud, Almanya merkezli Hetzner Online tarafından sunulan bir bulut altyapısı (IaaS) hizmetidir. Sanal sunucular (CX serisi), depolama, ağ kaynakları ve yönetilen veritabanları gibi temel bulut hizmetleri sağlar. Özellikle uygun fiyatları, yüksek performanslı NVMe depolama seçenekleri ve gigabit seviyesindeki ağ bağlantıları ile dikkat çeker. Hetzner Cloud, kullanıcıların sanal makineleri hızlı bir şekilde dağıtmasına, yönetmesine ve ölçeklendirmesine olanak tanır. Genellikle geliştiriciler, küçük ve orta ölçekli işletmeler ve maliyet etkinliği arayan projeler tarafından tercih edilir. API erişimi sayesinde, sunucu oluşturma, silme, IP atama gibi işlemler programatik olarak kontrol edilebilir. Ancak, AWS veya Azure gibi “hiper ölçekli” bulut sağlayıcılarının sunduğu kadar zengin bir ekosisteme (örn. çok sayıda yönetilen hizmet) sahip değildir. Bu nedenle, izleme ve otomasyon gibi bazı alanlarda harici araçlarla entegrasyon gerekebilir. Bizim senaryomuzda, Hetzner Cloud’da çalışan sanal sunucularımızın (instance’larımızın) CPU, RAM, disk I/O ve ağ kullanımı gibi metriklerini izlemeyi hedefleyeceğiz.

AWS CloudWatch Ne İşe Yarar?

AWS CloudWatch, Amazon Web Services (AWS) için kapsamlı bir izleme ve gözlemlenebilirlik hizmetidir. AWS kaynakları (EC2, Lambda, S3 vb.) ve şirket içi uygulamalarınız için veri toplar ve izler. CloudWatch; metrikler, günlükler (logs) ve olaylar (events) olmak üzere üç ana bileşene sahiptir. Metrikler, kaynaklarınızın performansını ve kullanımını gösteren zaman serisi verileridir (örn. CPU kullanımı, disk okuma/yazma, istek sayısı). CloudWatch, bu metrikleri otomatik olarak toplar veya özel metrikler göndermenize olanak tanır. Günlükler, uygulamalarınızdan ve hizmetlerinizden gelen log verilerini merkezi olarak toplamanızı, depolamanızı ve analiz etmenizi sağlar. Olaylar ise, AWS ortamınızdaki değişiklikleri veya özel olayları takip etmenize ve bunlara yanıt vermenize olanak tanır. CloudWatch’un en güçlü yönlerinden biri, bu metrikler, günlükler ve olaylar üzerinde alarmlar kurabilme ve bu alarmlar tetiklendiğinde çeşitli aksiyonlar (örn. SNS bildirimleri gönderme, Lambda fonksiyonu çalıştırma) başlatabilmesidir. Ayrıca, izleme verilerini görselleştirmek için özelleştirilebilir panolar (dashboards) sunar. Bu zengin özellik seti, Hetzner kaynaklarımızın da aynı merkezi sistemden izlenmesini son derece cazip hale getirir.

Altyapı Otomasyonunda Terraform’un Rolü

Terraform, HashiCorp tarafından geliştirilen açık kaynaklı bir altyapı kod olarak (Infrastructure as Code – IaC) aracıdır. AWS, Azure, Google Cloud, Hetzner Cloud ve daha birçok platformda bulut kaynaklarını güvenli ve verimli bir şekilde sağlamanıza ve yönetmenize olanak tanır. Terraform’un temel prensibi, istediğiniz altyapı durumunu bir yapılandırma dosyası (HCL – HashiCorp Configuration Language) aracılığıyla tanımlamanızdır. Daha sonra Terraform, bu durumu mevcut altyapınızla karşılaştırır ve aradaki farkları gidermek için gerekli API çağrılarını yapar. Bu yaklaşım, altyapıyı manuel müdahaleler yerine kod aracılığıyla yöneterek tekrarlanabilirliği, sürüm kontrolünü ve iş birliğini artırır.

Terraform’un “provider” (sağlayıcı) modeli, farklı bulut platformlarıyla entegrasyonunu sağlar. Her bulut sağlayıcısı veya hizmeti için bir Terraform sağlayıcısı bulunur (örn. aws sağlayıcısı, hcloud sağlayıcısı). Bu sağlayıcılar, ilgili API’lerle etkileşime girerek kaynakları oluşturur, günceller veya siler. Bizim senaryomuzda, hem AWS kaynaklarını (CloudWatch alarmları, Lambda fonksiyonları) hem de Hetzner Cloud kaynaklarını (varsa, örneğin sunucu listelerini almak için) Terraform ile yönetebileceğiz. Bu, tek bir araç ve tek bir kod tabanı üzerinden hibrit bulut altyapımızın izleme bileşenlerini tamamen otomatikleştirebileceğimiz anlamına gelir. Bu sayede, izleme altyapısının kendisi de tıpkı diğer altyapı bileşenleri gibi sürüm kontrolü altında, şeffaf ve yönetilebilir olacaktır.

Hetzner Metriklerini CloudWatch’a Aktarma Mimarisi Nasıl Kurulur?

Hetzner Cloud, AWS CloudWatch ile doğrudan bir entegrasyon sunmadığından, metrikleri Hetzner ortamından çekip CloudWatch’a gönderecek bir köprü kurmamız gerekiyor. Bu mimari genellikle birkaç ana bileşenden oluşur ve verinin Hetzner sunucularından CloudWatch’a güvenli ve verimli bir şekilde akmasını sağlar. Genelde izleme çözümleri için kullanılan “pull” (çekme) veya “push” (gönderme) modellerini burada da uygulayabiliriz. Bizim senaryomuzda, Hetzner’dan veriyi alıp AWS CloudWatch’a “push” etme modelini kullanacağız.

Mimariyi basitleştirmek gerekirse, adımlar şu şekildedir:

  1. Hetzner API Üzerinden Veri Toplama: Hetzner Cloud’un kendi yönetim panelinde bazı temel sunucu metrikleri (CPU, ağ kullanımı gibi) görünür durumdadır. Ancak daha detaylı ve özelleştirilebilir metrikler için genellikle sunucuların içine yerleştirilmiş ajanlar kullanmak daha yaygındır. Ancak basit başlangıç için, Hetzner’ın sağladığı API üzerinden sunucu listesini ve temel durum bilgilerini çekebiliriz. Daha ileri düzey senaryolarda, Hetzner sunucularına kurulacak bir node_exporter (Prometheus ekosisteminden) veya benzeri bir ajan ile CPU, RAM, disk I/O, ağ, süreçler gibi çok daha detaylı işletim sistemi seviyesi metrikler toplanabilir. Bu metrikler daha sonra bir betik aracılığıyla işlenmeye hazır hale getirilir.
  2. Veri İşleme ve AWS’ye Gönderme: Toplanan metriklerin CloudWatch’un anlayacağı formata dönüştürülmesi ve AWS’ye gönderilmesi gerekir. Bu adım için genellikle Python veya Bash gibi dillerde yazılmış özel bir betik kullanılır. Bu betik, Hetzner API’sinden veya yerel ajanlardan aldığı metrikleri CloudWatch’un PutMetricData API’sine uygun hale getirir. Bu metrikleri AWS’ye göndermenin birkaç yolu vardır:
    • AWS Lambda Fonksiyonu: En yaygın ve sunucusuz (serverless) yaklaşım. Belirli aralıklarla (örn. her 5 dakikada bir) tetiklenecek bir Lambda fonksiyonu yazılır. Bu fonksiyon, Hetzner API’sine bağlanır, metrikleri çeker, işler ve CloudWatch’a gönderir. Lambda’nın avantajları; sunucu yönetimi olmaması, kullandıkça öde modeli ve kolay ölçeklenebilirliktir.
    • AWS EC2 Üzerinde Çalışan Bir Ajan/Betik: Daha fazla kontrol gerektiren veya daha karmaşık veri işleme adımları olan senaryolarda, bir EC2 instance’ı üzerinde çalışan bir betik veya özel bir izleme ajanı kullanılabilir. Bu ajan, Hetzner sunucularından SSH veya API aracılığıyla metrikleri çeker ve CloudWatch’a gönderir. Bu yaklaşım, ajan ve sunucu yönetimi gerektirir ancak daha fazla esneklik sunabilir.
    • Hetzner Sunucusu Üzerinde Çalışan Bir Ajan: Metrikleri Hetzner sunucusunun kendisinden toplayıp doğrudan CloudWatch’a gönderen bir ajan (örn. AWS CloudWatch Agent’ın özel yapılandırması veya Prometheus Agent’ın remote_write özelliği ile) daha karmaşık olabilir ancak en düşük gecikmeyle veri sağlar. Ancak bu, Hetzner sunucularının AWS kimlik bilgilerine erişimi olmasını gerektirebilir ki bu güvenlik açısından dikkatli yönetilmesi gereken bir durumdur. Bizim örneğimizde, AWS Lambda yaklaşımını benimseyeceğiz.
  3. Güvenlik ve İzinler: Metrik toplama ve gönderme sürecinde güvenlik kritik öneme sahiptir. Hetzner API token’ı ve AWS kimlik bilgileri güvenli bir şekilde yönetilmelidir. AWS tarafında, metrikleri CloudWatch’a gönderecek Lambda fonksiyonuna veya EC2 instance’ına minimum ayrıcalık ilkesiyle IAM rolleri ve politikaları atanmalıdır. Bu roller, yalnızca cloudwatch:PutMetricData, logs:CreateLogGroup, logs:CreateLogStream ve logs:PutLogEvents gibi gerekli izinleri içermelidir. Hetzner API token’ı ise AWS Secrets Manager gibi güvenli bir hizmette saklanmalı ve Lambda fonksiyonu tarafından çalışma zamanında çekilmelidir. Bu, hassas bilgilerin kodda veya yapılandırma dosyalarında açıkça bulunmasını engeller.

    Bu mimari, Hetzner Cloud’daki kaynaklarınızın performans ve durum verilerini, AWS ekosisteminizin geri kalanıyla birlikte merkezi olarak izlemenize olanak tanır. Terraform ile bu mimarinin tüm AWS bileşenlerini (Lambda, IAM, EventBridge, CloudWatch panoları ve alarmları) otomatik olarak dağıtabilirsiniz.

    Adım Adım Uygulama: Terraform ile Entegrasyon Nasıl Yapılır?

    Şimdi, bu teorik mimariyi pratiğe dökelim ve Hetzner Cloud kaynaklarını AWS CloudWatch’a Terraform ile nasıl entegre edeceğimizi adım adım görelim. Bu bölüm, gerekli ön koşullardan başlayıp, IAM izinlerinin yapılandırılmasına, metrik toplama betiğinin oluşturulmasına ve son olarak AWS Lambda ve EventBridge ile otomasyonun sağlanmasına kadar tüm süreci kapsayacaktır.

    Ön Koşullar ve Hazırlıklar Nelerdir?

    Entegrasyona başlamadan önce aşağıdaki araç ve bilgilere sahip olduğunuzdan emin olun:

    1. AWS Hesabı ve Kimlik Bilgileri: AWS CLI’yi yapılandırmak ve Terraform’un AWS kaynaklarını yönetebilmesi için bir AWS hesabınız ve IAM kullanıcınız (veya rolünüz) olmalı. Bu kullanıcının Terraform ile kaynak oluşturma/değiştirme yetkileri bulunmalıdır. AWS CLI’nizin yapılandırılmış olduğundan emin olun (aws configure).
    2. Hetzner Cloud Hesabı ve API Token: Hetzner Cloud hesabınız olmalı ve bir API token’ı oluşturmuş olmalısınız. Bu token, Hetzner API’sine erişim sağlamak için kullanılacaktır. Hetzner Cloud panelinizden “Access” -> “API Tokens” bölümünden yeni bir token oluşturabilirsiniz. Bu token’ı güvende tutun.
    3. Terraform Kurulumu: Bilgisayarınızda Terraform’un kurulu olduğundan emin olun. Resmi HashiCorp web sitesinden indirme ve kurulum talimatlarına ulaşabilirsiniz.
    4. Python ve Bağımlılıklar: Metrik toplama betiğini yazmak için Python (tercihen 3.9 veya üstü) kurulu olmalı. Gerekli kütüphaneler (boto3 AWS SDK için, hcloud Hetzner API için) pip ile kurulabilir.
    5. Zip Arşivleyici: Lambda fonksiyonunuzun kodunu bir zip dosyasına paketlemek için bir araç (örn. Linux/macOS’ta zip komutu, Windows’ta uygun bir araç) gerekecektir.

    Bu ön koşulları tamamladıktan sonra, Terraform projenizi oluşturmaya başlayabiliriz. Boş bir dizin oluşturun ve tüm Terraform yapılandırma dosyalarınızı bu dizinin içinde tutun.

    Terraform Yapılandırması: Providers ve IAM İzinleri

    Terraform projemizin temelini oluşturan sağlayıcıları (providers) tanımlayarak ve AWS tarafında gerekli IAM (Identity and Access Management) rollerini ve politikalarını oluşturarak başlıyoruz. Bu adımlar, Lambda fonksiyonumuzun CloudWatch’a metrik gönderebilmesi için gerekli yetkileri sağlar.

    Aşağıdaki Terraform kodunu main.tf adlı bir dosyaya kaydedin: 

    # AWS Sağlayıcısını Tanımlama
provider "aws" {
  region = var.aws_region # Değişkenlerden alınacak bölge
}

# Hetzner Cloud Sağlayıcısını Tanımlama (sadece Hetzner kaynaklarını yönetmek isterseniz gerekli, burada sadece token için kullanıldı)
provider "hcloud" {
  token = var.hcloud_token
}

# Hetzner API Token'ı ve AWS Bölgesi için değişkenler
variable "hcloud_token" {
  description = "Hetzner Cloud API Tokenı"
  type        = string
  sensitive   = true # Hassas bilgi olduğunu belirtir
}

variable "aws_region" {
  description = "AWS Bölgesi"
  type        = string
  default     = "eu-central-1" # Varsayılan bölge olarak Frankfurt seçilebilir
}

# CloudWatch'a metrik yayınlayacak Lambda veya EC2 için IAM Rolü
resource "aws_iam_role" "cloudwatch_publisher_role" {
  name = "cloudwatch-metrics-publisher-role"

  # Bu rolü kimlerin üstlenebileceğini tanımlar (Lambda hizmeti)
  assume_role_policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
      {
        Action = "sts:AssumeRole",
        Effect = "Allow",
        Principal = {
          Service = "lambda.amazonaws.com" # Bu rolü Lambda fonksiyonlarının üstlenmesine izin verir
        },
      },
    ],
  })

  tags = {
    Environment = "Monitoring"
  }
}

# CloudWatch'a metrik gönderme ve log yazma yetkisi veren IAM Politikası
resource "aws_iam_policy" "cloudwatch_publish_policy" {
  name        = "cloudwatch-publish-policy"
  description = "Allows publishing custom metrics to CloudWatch and writing logs"

  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
      {
        Action = [
          "cloudwatch:PutMetricData", # Özel metrikleri CloudWatch'a gönderme izni
          "logs:CreateLogGroup",      # Log grubu oluşturma izni
          "logs:CreateLogStream",     # Log akışı oluşturma izni
          "logs:PutLogEvents"         # Log olaylarını gönderme izni
        ],
        Effect   = "Allow",
        Resource = "*" # Tüm kaynaklar için izin (daha kısıtlı yapılabilir)
      },
    ],
  })

  tags = {
    Environment = "Monitoring"
  }
}

# IAM Rolü ile IAM Politikasını İlişkilendirme
resource "aws_iam_role_policy_attachment" "attach_cloudwatch_publish_policy" {
  role       = aws_iam_role.cloudwatch_publisher_role.name
  policy_arn = aws_iam_policy.cloudwatch_publish_policy.arn
}

# Lambda fonksiyonunun kullanacağı IAM Instance Profile (isteğe bağlı, EC2 için daha çok)
# Lambda için direk rol ARN'ı yeterlidir.

    Yukarıdaki kod bloğu, AWS üzerinde CloudWatch'a metrik gönderebilecek ve log yazabilecek bir IAM rolü tanımlar. Bu rol, daha sonra Lambda fonksiyonumuz tarafından üstlenilecektir. hcloud_token değişkenini terraform.tfvars dosyasına veya doğrudan komut satırına parametre olarak sağlamayı unutmayın. Örneğin: terraform plan -var='hcloud_token=YOUR_HETZNER_API_TOKEN'. Güvenlik için, bu tür hassas bilgileri Terraform state dosyasına kaydetmek yerine AWS Secrets Manager gibi bir hizmette saklamak ve Lambda'nın çalışma zamanında çekmesini sağlamak daha iyi bir uygulamadır. Ancak bu örnekte basitlik adına doğrudan değişken olarak geçildi.

    Hetzner Metriklerini Çeken Betik Oluşturma ve Dağıtma

    Şimdi Hetzner Cloud sunucularından metrikleri çekecek ve bunları CloudWatch'a gönderecek Python betiğini oluşturalım. Bu betik, Hetzner API'sini kullanarak sunucu listesini alacak ve her bir sunucu için varsayılan metrikleri (gerçek metrikler yerine örnek değerler) oluşturup AWS Boto3 SDK'sı aracılığıyla CloudWatch'a gönderecektir. Gerçek bir senaryoda, bu betik, Hetzner sunucularına kurulu bir izleme ajanından (örn. node_exporter) veya Hetzner'ın kendi metrik API'sinden (varsa) gerçek verileri çekerdi.

    Aşağıdaki Python kodunu main.py adlı bir dosyaya kaydedin: 

    import os
import boto3
import json
from hcloud import Client
from datetime import datetime

# Hetzner API istemcisi için token, ortam değişkeninden alınır
HETZNER_API_TOKEN = os.environ.get("HCLOUD_TOKEN")
hcloud_client = Client(token=HETZNER_API_TOKEN)

# AWS CloudWatch istemcisi, bölge ortam değişkeninden alınır
cloudwatch = boto3.client('cloudwatch', region_name=os.environ.get("AWS_REGION", "eu-central-1"))

def get_hetzner_server_metrics():
    """
    Hetzner Cloud sunucularından metrikleri çeker.
    Bu örnekte, doğrudan Hetzner Cloud API'sinden gerçek performans metrikleri çekmek yerine,
    sunucu bilgilerini alıp varsayılan/örnek performans metrikleri oluşturuyoruz.
    Gerçek senaryoda, Hetzner sunucuları üzerinde çalışan bir ajandan veya
    Hetzner'ın sunduğu bir metrik API'sinden veri alınmalıdır.
    """
    servers = hcloud_client.servers.get_all()
    metrics = []
    current_time = datetime.utcnow().isoformat()

    for server in servers:
        # Her sunucu için benzersiz boyutlar (dimensions) tanımlıyoruz
        dimensions = [
            {'Name': 'ServerId', 'Value': str(server.id)},
            {'Name': 'ServerName', 'Value': server.name},
            {'Name': 'ServerType', 'Value': server.server_type.name}
        ]

        # Örnek CPU kullanım metriği
        metrics.append({
            'MetricName': 'CPUUtilization',
            'Dimensions': dimensions,
            'Timestamp': current_time,
            'Value': float(os.environ.get(f"CPU_UTIL_{server.id}", "50.0")), # Dinamik veya varsayılan değer
            'Unit': 'Percent'
        })
        # Örnek Bellek kullanım metriği
        metrics.append({
            'MetricName': 'MemoryUtilization',
            'Dimensions': dimensions,
            'Timestamp': current_time,
            'Value': float(os.environ.get(f"MEM_UTIL_{server.id}", "70.0")), # Dinamik veya varsayılan değer
            'Unit': 'Percent'
        })
        # Örnek Gelen Ağ Trafiği metriği (Bytes)
        metrics.append({
            'MetricName': 'NetworkIn',
            'Dimensions': dimensions,
            'Timestamp': current_time,
            'Value': float(os.environ.get(f"NET_IN_{server.id}", "123456")), # Dinamik veya varsayılan değer
            'Unit': 'Bytes'
        })
        # Örnek Giden Ağ Trafiği metriği (Bytes)
        metrics.append({
            'MetricName': 'NetworkOut',
            'Dimensions': dimensions,
            'Timestamp': current_time,
            'Value': float(os.environ.get(f"NET_OUT_{server.id}", "654321")), # Dinamik veya varsayılan değer
            'Unit': 'Bytes'
        })
    return metrics

def publish_metrics_to_cloudwatch(metrics):
    """
    Toplanan metrikleri AWS CloudWatch'a gönderir.
    """
    if not metrics:
        print("Gönderilecek metrik bulunamadı.")
        return

    # CloudWatch PutMetricData API'si tek seferde en fazla 20 metrik girişi kabul eder.
    # Bu yüzden metrikleri parçalara ayırıyoruz.
    for i in range(0, len(metrics), 20):
        batch = metrics[i:i+20]
        try:
            response = cloudwatch.put_metric_data(
                Namespace='HetznerCloud', # Özel metrikler için bir namespace tanımlıyoruz
                MetricData=batch
            )
            print(f"CloudWatch'a {len(batch)} metrik gönderildi. Yanıt: {response.get('ResponseMetadata', {}).get('HTTPStatusCode')}")
        except Exception as e:
            print(f"Metrik gönderilirken hata oluştu: {e}")

def lambda_handler(event, context):
    """
    AWS Lambda tarafından çağrılacak ana fonksiyon.
    """
    print(f"Lambda Tetiklendi: {json.dumps(event)}")
    if not HETZNER_API_TOKEN:
        print("HCLOUD_TOKEN çevre değişkeni ayarlanmamış. Lütfen Lambda yapılandırmasını kontrol edin.")
        return {
            'statusCode': 500,
            'body': json.dumps('HCLOUD_TOKEN missing')
        }

    hetzner_metrics = get_hetzner_server_metrics()
    publish_metrics_to_cloudwatch(hetzner_metrics)

    return {
        'statusCode': 200,
        'body': json.dumps('Hetzner metrikleri başarıyla CloudWatch\'a gönderildi!')
    }

if __name__ == "__main__":
    # Yerel test için
    os.environ['HCLOUD_TOKEN'] = 'YOUR_HETZNER_API_TOKEN' # Yerel test için Hetzner token'ınızı buraya girin
    os.environ['AWS_REGION'] = 'eu-central-1' # Yerel test için AWS bölgenizi girin
    lambda_handler(None, None)

    Bu betiği Lambda'ya dağıtmadan önce, gerekli Python kütüphanelerini (boto3, hcloud) de içeren bir zip dosyası oluşturmanız gerekir. Yeni bir dizin oluşturun, main.py dosyasını içine kopyalayın ve ardından kütüphaneleri bu dizine yükleyin: 

    mkdir lambda_package
cp main.py lambda_package/
pip install boto3 hcloud -t lambda_package/
cd lambda_package/
zip -r ../lambda_function_payload.zip .
cd ..

    Bu komutlar, main.py dosyasını ve tüm bağımlılıklarını içeren lambda_function_payload.zip adlı bir zip dosyası oluşturacaktır.

    AWS Lambda ve EventBridge ile Otomatik Metrik Toplama

    Şimdi Terraform'u kullanarak bu zip dosyasını bir AWS Lambda fonksiyonu olarak dağıtalım ve AWS EventBridge (eski adıyla CloudWatch Events) kullanarak belirli aralıklarla tetiklenmesini sağlayalım. Bu, Hetzner metriklerinin otomatik olarak toplanıp CloudWatch'a gönderilmesini sağlayacaktır. Bu Terraform kodunu da main.tf dosyanıza ekleyebilirsiniz. 

    # Lambda fonksiyonu için zip dosyasını yükleyen resource
resource "aws_s3_bucket_object" "lambda_zip_upload" {
  bucket = var.lambda_s3_bucket # Lambda zip dosyasının yükleneceği S3 bucket
  key    = "lambda_function_payload.zip"
  source = "lambda_function_payload.zip" # Yerel zip dosyamız
  etag   = filemd5("lambda_function_payload.zip") # Dosya değişikliğinde güncellenmesi için
}

# AWS Lambda Fonksiyonu
resource "aws_lambda_function" "hetzner_metrics_collector" {
  filename      = "lambda_function_payload.zip" # Yerel dosya yolunu belirtiyoruz, S3'e yüklendiği için bu aslında S3 bucket objesine işaret ediyor.
  s3_bucket     = aws_s3_bucket_object.lambda_zip_upload.bucket
  s3_key        = aws_s3_bucket_object.lambda_zip_upload.key
  function_name = "HetznerCloudMetricsCollector"
  role          = aws_iam_role.cloudwatch_publisher_role.arn # Daha önce oluşturduğumuz IAM rolü
  handler       = "main.lambda_handler" # Zip içindeki ana dosya (main.py) ve fonksiyon adı (lambda_handler)
  runtime       = "python3.9"
  timeout       = 300 # Saniye cinsinden (5 dakika)
  memory_size   = 128 # MB cinsinden

  # Hetzner API token'ı ve AWS bölgesini Lambda ortam değişkenleri olarak geçiyoruz
  environment {
    variables = {
      HCLOUD_TOKEN = var.hcloud_token
      AWS_REGION   = var.aws_region
    }
  }

  # Lambda kodunda bir değişiklik olduğunda fonksiyonu yeniden dağıtmak için
  source_code_hash = filebase64sha256("lambda_function_payload.zip")

  tags = {
    Environment = "Monitoring"
  }
}

# Lambda zip dosyasının yükleneceği S3 bucket'ı (eğer yoksa oluşturur)
resource "aws_s3_bucket" "lambda_code_bucket" {
  bucket = var.lambda_s3_bucket
  acl    = "private" # Özel olmalı

  versioning {
    enabled = true
  }

  tags = {
    Environment = "Monitoring"
  }
}

variable "lambda_s3_bucket" {
  description = "Lambda kodunun depolanacağı S3 bucket adı"
  type        = string
  default     = "hetzner-metrics-lambda-code-bucket-unique" # Benzersiz bir isim seçin
}

# CloudWatch EventBridge Kuralı: Lambda'yı her 5 dakikada bir tetikler
resource "aws_cloudwatch_event_rule" "every_five_minutes" {
  name                = "HetznerCloudMetricsEveryFiveMinutes"
  description         = "Triggers Hetzner Cloud metrics collection every 5 minutes"
  schedule_expression = "rate(5 minutes)" # Her 5 dakikada bir çalıştır
  is_enabled          = true

  tags = {
    Environment = "Monitoring"
  }
}

# EventBridge Kuralının hedefi: Lambda fonksiyonu
resource "aws_cloudwatch_event_target" "lambda_target" {
  rule      = aws_cloudwatch_event_rule.every_five_minutes.name
  target_id = "HetznerCloudMetricsLambdaTarget"
  arn       = aws_lambda_function.hetzner_metrics_collector.arn
}

# CloudWatch EventBridge'in Lambda fonksiyonunu çağırmasına izin veren izin
resource "aws_lambda_permission" "allow_cloudwatch_to_call_lambda" {
  statement_id  = "AllowExecutionFromCloudWatch"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.hetzner_metrics_collector.function_name
  principal     = "events.amazonaws.com"
  source_arn    = aws_cloudwatch_event_rule.every_five_minutes.arn
}

    Terraform kodunuzu çalıştırın: 

    terraform init
terraform plan -var='hcloud_token=YOUR_HETZNER_API_TOKEN'
terraform apply -var='hcloud_token=YOUR_HETZNER_API_TOKEN'

    Bu adımları tamamladığınızda, Hetzner Cloud metrikleriniz otomatik olarak AWS CloudWatch'a akmaya başlayacaktır. Birkaç dakika sonra AWS konsoluna gidip CloudWatch hizmeti altında "Metrics" bölümünde "HetznerCloud" ad alanını görmeniz gerekir. Bu ad alanının altında, Hetzner sunucularınızdan gelen "CPUUtilization", "MemoryUtilization" gibi metrikleri görebilirsiniz.

    CloudWatch Panoları ve Alarmları ile İzlemeyi Geliştirme

    Metrikler CloudWatch'a akmaya başladıktan sonra, bu verileri anlamlı hale getirmek için panolar (dashboards) oluşturmak ve olası sorunlar için alarmlar kurmak gereklidir. Bu bölüm, Hetzner Cloud metriklerinizi AWS CloudWatch'ta nasıl görselleştireceğinizi ve proaktif bildirimler için alarmlarınızı nasıl yapılandıracağınızı gösterecektir. Yine bu işlemleri Terraform ile otomatize ederek, izleme altyapınızın kod olarak yönetilebilirliğini sağlayacağız.

    Özel CloudWatch Panoları Nasıl Oluşturulur?

    CloudWatch panoları, birden fazla metriği, log grubunu veya alarmı tek bir görsel arayüzde birleştirmenize olanak tanır. Bu, Hetzner ve AWS kaynaklarınızın genel durumunu tek bir yerden hızlıca anlamak için idealdir. Terraform ile bir pano oluştururken, panonun içeriğini (widget'lar) JSON formatında tanımlarsınız.

    Aşağıdaki Terraform kodunu main.tf dosyanıza ekleyerek Hetzner sunucu performansını gösteren basit bir pano oluşturabilirsiniz: 

    resource "aws_cloudwatch_dashboard" "hetzner_dashboard" {
  dashboard_name = "HetznerCloudMonitoringDashboard"

  dashboard_body = jsonencode({
    widgets = [
      {
        type   = "metric",
        x      = 0,
        y      = 0,
        width  = 12,
        height = 6,
        properties = {
          metrics = [
            # CPU Kullanımı
            ["HetznerCloud", "CPUUtilization", "ServerName", "my-hetzner-server-01", { "stat": "Average", "label": "Hetzner Sunucu 1 CPU", "color": "#1f77b4" }],
            ["HetznerCloud", "CPUUtilization", "ServerName", "my-hetzner-server-02", { "stat": "Average", "label": "Hetzner Sunucu 2 CPU", "color": "#ff7f0e" }],
            # Bellek Kullanımı
            ["HetznerCloud", "MemoryUtilization", "ServerName", "my-hetzner-server-01", { "stat": "Average", "label": "Hetzner Sunucu 1 Bellek", "color": "#2ca02c" }],
            ["HetznerCloud", "MemoryUtilization", "ServerName", "my-hetzner-server-02", { "stat": "Average", "label": "Hetzner Sunucu 2 Bellek", "color": "#d62728" }],
          ],
          period    = 300, # 5 dakika
          stat      = "Average",
          region    = var.aws_region,
          title     = "Hetzner Sunucu Performansı",
          view      = "timeSeries",
          stacked   = false
        }
      },
      {
        type   = "metric",
        x      = 12,
        y      = 0,
        width  = 12,
        height = 6,
        properties = {
          metrics = [
            # Gelen Ağ Trafiği
            ["HetznerCloud", "NetworkIn", "ServerName", "my-hetzner-server-01", { "stat": "Sum", "label": "Hetzner Sunucu 1 Gelen Ağ", "color": "#9467bd" }],
            ["HetznerCloud", "NetworkIn", "ServerName", "my-hetzner-server-02", { "stat": "Sum", "label": "Hetzner Sunucu 2 Gelen Ağ", "color": "#8c564b" }],
            # Giden Ağ Trafiği
            ["HetznerCloud", "NetworkOut", "ServerName", "my-hetzner-server-01", { "stat": "Sum", "label": "Hetzner Sunucu 1 Giden Ağ", "color": "#e377c2" }],
            ["HetznerCloud", "NetworkOut", "ServerName", "my-hetzner-server-02", { "stat": "Sum", "label": "Hetzner Sunucu 2 Giden Ağ", "color": "#7f7f7f" }]
          ],
          period    = 300,
          stat      = "Sum",
          region    = var.aws_region,
          title     = "Hetzner Sunucu Ağ Trafiği (Bytes)",
          view      = "timeSeries",
          yAxis = {
            left = {
              label = "Bytes/sn",
              showUnits = true
            }
          }
        }
      },
      {
        type   = "text",
        x      = 0,
        y      = 6,
        width  = 24,
        height = 3,
        properties = {
          markdown = "Hetzner Cloud İzleme Durumu\nBu pano, Hetzner Cloud üzerindeki kritik sunucu metriklerini görselleştirir."
        }
      }
    ]
  })

  tags = {
    Environment = "Monitoring"
  }
}

    Bu Terraform kodu, Hetzner Cloud sunucularınızın CPU kullanımını, bellek kullanımını ve ağ trafiğini gösteren iki metrik widget'ı ve bir metin widget'ı içeren bir CloudWatch panosu oluşturur. Metriklerin ServerName boyutunu kendi Hetzner sunucularınızın adlarına göre güncellemeyi unutmayın. Terraform'u tekrar uyguladığınızda bu pano AWS CloudWatch konsolunda görünür olacaktır.

    Hetzner Metrikleri İçin Alarm Kurulumu

    Panolar sadece durumu gösterir; gerçek sorun tespiti için alarmlara ihtiyacımız var. CloudWatch alarmları, belirli bir metriğin önceden tanımlanmış bir eşiği aştığında bildirim göndermek veya otomatik eylemleri tetiklemek için kullanılır. Bu alarmları, AWS SNS (Simple Notification Service) topiklerine bağlayarak e-posta, SMS veya diğer aboneliklerle bildirimler alabiliriz.

    Aşağıdaki Terraform kodunu kullanarak, Hetzner sunucularınızdan biri için yüksek CPU kullanımı alarmı ve bu alarm tetiklendiğinde e-posta gönderen bir SNS topici oluşturabilirsiniz: 

    # Alarm bildirimlerinin gönderileceği SNS Topici
resource "aws_sns_topic" "hetzner_alerts_topic" {
  name = "HetznerCloudAlerts"

  tags = {
    Environment = "Monitoring"
  }
}

# SNS Topici'ne e-posta aboneliği (e-posta adresinizi buraya girin)
resource "aws_sns_topic_subscription" "email_subscription" {
  topic_arn = aws_sns_topic.hetzner_alerts_topic.arn
  protocol  = "email"
  endpoint  = "your-email@example.com" # Buraya gerçek e-posta adresinizi girin ve aboneliği onaylayın
  # pending_confirmation_timeout = "P10M" # Aboneliğin onaylanması için süre
}

# Yüksek CPU kullanımı için CloudWatch Alarmı
resource "aws_cloudwatch_metric_alarm" "high_cpu_alarm" {
  alarm_name          = "Hetzner-High-CPU-Utilization-my-server-01"
  comparison_operator = "GreaterThanThreshold" # Eşiğin üzerinde olduğunda alarm ver
  evaluation_periods  = "2"                    # Kaç değerlendirme dönemi boyunca eşik aşılmalı
  metric_name         = "CPUUtilization"       # İzlenecek metrik adı
  namespace           = "HetznerCloud"         # Metriğin ad alanı
  period              = "300"                  # Metriklerin toplanma periyodu (5 dakika)
  statistic           = "Average"              # Metrik istatistiği
  threshold           = "80"                   # Alarm eşiği (%80 CPU)
  alarm_description   = "Hetzner sunucunun ortalama CPU kullanımı 10 dakika boyunca %80'in üzerinde."
  actions_enabled     = true                   # Alarm eylemlerini etkinleştir

  # Alarm tetiklendiğinde veya düzeldiğinde yapılacak eylemler
  alarm_actions       = [aws_sns_topic.hetzner_alerts_topic.arn]
  ok_actions          = [aws_sns_topic.hetzner_alerts_topic.arn] # Durum normale döndüğünde de bildirim

  # Alarmın uygulanacağı sunucuyu belirtmek için boyutlar
  dimensions = {
    ServerName = "my-hetzner-server-01" # Belirli bir sunucu için alarm
  }

  tags = {
    Environment = "Monitoring"
  }
}

# Yüksek Bellek kullanımı için CloudWatch Alarmı (ek örnek)
resource "aws_cloudwatch_metric_alarm" "high_memory_alarm" {
  alarm_name          = "Hetzner-High-Memory-Utilization-my-server-01"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = "3"
  metric_name         = "MemoryUtilization"
  namespace           = "HetznerCloud"
  period              = "300"
  statistic           = "Average"
  threshold           = "90" # %90 Bellek üzerinde
  alarm_description   = "Hetzner sunucunun ortalama bellek kullanımı 15 dakika boyunca %90'ın üzerinde."
  actions_enabled     = true
  alarm_actions       = [aws_sns_topic.hetzner_alerts_topic.arn]
  ok_actions          = [aws_sns_topic.hetzner_alerts_topic.arn]

  dimensions = {
    ServerName = "my-hetzner-server-01"
  }

  tags = {
    Environment = "Monitoring"
  }
}

    Bu kod parçası, HetznerCloudAlerts adında bir SNS topici oluşturur ve buna bir e-posta aboneliği ekler. your-email@example.com yerine kendi e-posta adresinizi girmeniz ve AWS'den gelen abonelik onay e-postasını onaylamanız gerekmektedir. Ardından, my-hetzner-server-01 adlı sunucunun CPU kullanımı 10 dakika boyunca %80'in üzerine çıktığında tetiklenecek bir alarm tanımlar. Benzer şekilde, bellek kullanımı için de bir alarm örneği eklenmiştir. Bu alarmlar tetiklendiğinde, SNS topici aracılığıyla size e-posta bildirimleri gönderilecektir. Terraform'u tekrar uyguladığınızda bu alarmlar da devreye alınacaktır. Böylece Hetzner kaynaklarınızın izlemesini görselleştirmekle kalmayacak, aynı zamanda olası kritik durumlar hakkında anında bilgi sahibi olabileceksiniz.

    Vaka Analizi: Büyük Ölçekli Bir Uygulama İçin Hibrit İzleme

    Bir e-ticaret şirketi olan "GlobalShop", operasyonel maliyetleri optimize etmek ve belirli bölgelerdeki müşterilere daha düşük gecikme süresi sunmak amacıyla hibrit bir altyapı kullanmaya karar verdi. Şirketin ana e-ticaret platformu ve veritabanları AWS (EC2, RDS, Lambda) üzerinde çalışırken, yoğun trafik alan statik içerik sunumu, önbellekleme katmanları (Redis, Varnish) ve bazı mikro hizmetler Hetzner Cloud üzerinde konumlandırılmıştı. Bu ayrım, özellikle Avrupa'daki kullanıcılar için performansı artırırken, AWS'deki yönetilen hizmetlerin avantajlarından da yararlanılmasını sağlıyordu.

    Ancak, bu hibrit mimari, operasyon ekibi için yeni bir zorluk doğurdu: izleme. AWS kaynakları CloudWatch ile kolayca izlenirken, Hetzner kaynaklarının ayrı bir izleme sistemi üzerinden takip edilmesi gerekiyordu. Bu durum, olay yönetimi sırasında kritik bir aksaklığa yol açtı: Müşteriler, ürün sayfalarında yavaş yükleme süreleri rapor etmeye başladığında, operasyon ekibi sorunun AWS mi yoksa Hetzner tarafında mı olduğunu anlamakta zorlandı. İki farklı izleme panosu arasında geçiş yapmak, korelasyon kurmak ve kök nedeni bulmak zaman kaybına neden oldu ve hizmet kesintisi uzadı.

    Bu sorunu çözmek için GlobalShop, makalede anlatılan Hetzner-CloudWatch entegrasyon stratejisini uygulamaya karar verdi. Terraform kullanarak, aşağıdaki adımları gerçekleştirdiler:

    1. Hetzner Cloud API'sini sorgulayan ve metrikleri (CPU, bellek, disk I/O, ağ trafiği) toplayan bir Python betiği geliştirdiler.
    2. Bu betiği, AWS Lambda fonksiyonu olarak dağıttılar. Lambda, her 5 dakikada bir EventBridge tarafından tetiklenerek Hetzner metriklerini çekip "HetznerCloud" ad alanı altında CloudWatch'a gönderdi.
    3. Terraform ile, bu Lambda fonksiyonunun ihtiyaç duyduğu IAM rolleri ve politikaları otomatik olarak oluşturuldu. Hetzner API token'ı AWS Secrets Manager'da güvenli bir şekilde saklandı ve Lambda tarafından çalışma zamanında çekildi.
    4. Son olarak, CloudWatch üzerinde hem AWS hem de Hetzner metriklerini birleştiren merkezi panolar oluşturdular. Ayrıca, Hetzner sunucularındaki CPU ve bellek kullanımı belirli eşikleri aştığında tetiklenecek alarmlar (SNS üzerinden Slack'e bildirim gönderen) yapılandırıldı.

    Bu entegrasyonun sonucunda, GlobalShop operasyon ekibi tek bir CloudWatch panosundan tüm hibrit altyapılarının sağlığını ve performansını izleyebildi. Bir sonraki yavaşlama olayında, sorun Hetzner üzerindeki önbellekleme sunucularından birinin aşırı bellek tüketimi nedeniyle kaynaklandı. CloudWatch panosundaki merkezi görünüm ve tetiklenen yüksek bellek alarmı sayesinde ekip, sorunu saniyeler içinde tespit etti ve hızla müdahale ederek kesintiyi minimuma indirdi. Bu vaka analizi, farklı bulut platformları arasındaki veri silolarını ortadan kaldırmanın ve merkezi izlemenin, büyük ölçekli ve hibrit altyapılarda operasyonel verimliliği ve olay müdahale sürelerini nasıl kökten iyileştirebileceğini açıkça göstermektedir.

    Uzman İpucu: Büyük ölçekli yapılar için metrik gönderimini optimize etmek amacıyla, Hetzner sunucularınıza Prometheus Node Exporter kurarak metrikleri yerelde toplayabilir, ardından bir Prometheus sunucusu veya Grafana Agent ile AWS'deki bir Mimir/Cortex veya doğrudan CloudWatch metrik API'sine gönderebilirsiniz. Bu, Lambda'nın iş yükünü azaltabilir ve daha zengin metrik setleri sağlayabilir. Bu tür bir yaklaşım, daha granüler kontrol ve daha geniş metrik desteği sunar, ancak kurulum ve yönetim karmaşıklığını artırabilir.

    İleri Düzey İzleme Teknikleri ve En İyi Uygulamalar

    Hetzner Cloud kaynaklarını AWS CloudWatch ile izleme temel entegrasyonunu kurduktan sonra, izleme stratejinizi daha da geliştirmek ve operasyonel mükemmelliği artırmak için kullanabileceğiniz bazı ileri düzey teknikler ve en iyi uygulamalar bulunmaktadır. Bu yöntemler, hem izleme verimliliğini artırır hem de altyapınızın esnekliğini güçlendirir.

    1. Dinamik Alarm Eşikleri ve Anomali Tespiti: Sabit eşiklere dayalı alarmlar her zaman ideal değildir, çünkü sistem davranışları zamanla değişebilir veya belirli dönemlerde (örn. yoğun saatler, hafta sonları) farklılık gösterebilir. CloudWatch, metriklerinizdeki anormallikleri otomatik olarak öğrenmek ve dinamik eşikler belirlemek için Makine Öğrenimi (ML) destekli anomali tespiti sunar. Bu özelliği kullanarak, Hetzner sunucularınızdaki beklenmedik davranışları daha doğru bir şekilde tespit edebilirsiniz. Örneğin, normalde %30 CPU kullanan bir sunucunun aniden %50'ye çıkması, sabit bir %80 eşiğini aşmasa bile bir anomali olarak algılanabilir ve alarm tetiklenebilir. Bu, daha proaktif bir uyarı sistemi sağlar.
    2. Gelişmiş Log Yönetimi ve Analizi: Sadece metrikleri değil, Hetzner sunucularınızdan gelen logları da CloudWatch Logs'a gönderebilirsiniz. Bunun için Hetzner sunucularına CloudWatch Agent'ı kurabilir (ancak AWS kimlik bilgileri yönetimi zor olabilir) veya logları merkezi bir log toplama hizmetine (örn. Fluentd, Filebeat) gönderip oradan CloudWatch Logs'a aktarabilirsiniz. Logların CloudWatch Logs'a gelmesiyle, Log Insights kullanarak hızlı sorgulamalar yapabilir, hata ayıklama süreçlerini hızlandırabilir ve log tabanlı metrikler (örn. belirli hata mesajlarının sayısı) oluşturarak bunlara alarm kurabilirsiniz. Bu, derinlemesine sorun giderme yeteneğinizi artırır.
    3. Maliyet Optimizasyonu: CloudWatch, gönderilen metriklerin sayısına, log hacmine ve depolama süresine göre ücretlendirilir. Bu maliyetleri optimize etmek için şunları göz önünde bulundurun:
      • Yalnızca kritik metrikleri daha sık aralıklarla gönderin (örn. 1 dakika). Daha az önemli metrikler için daha uzun periyotlar (örn. 5 dakika veya 15 dakika) kullanın.
      • Lambda fonksiyonunuzun bellek ve zaman aşımı ayarlarını optimize edin. Gereksiz yere yüksek bellek veya uzun zaman aşımı kullanmak maliyeti artırır.
      • CloudWatch Logs'taki log saklama sürelerini düzenleyin. Uzun süre saklanması gerekmeyen logları daha kısa bir süre sonra silin veya daha ucuz bir depolama katmanına taşıyın (örn. S3'e arşivleme).
    4. Güvenlik Entegrasyonları: Hassas API anahtarlarınızı (Hetzner API token'ı) AWS Secrets Manager'da saklayın ve Lambda fonksiyonunuzun çalışma zamanında bu sırları çekmesini sağlayın. Bu, token'larınızı kodunuzdan veya yapılandırma dosyalarınızdan ayırarak güvenlik riskini azaltır. Ayrıca, IAM rolleri için her zaman "en düşük ayrıcalık ilkesi"ni (least privilege) uygulayın, yani yalnızca gerekli izinleri verin.
    5. Mobil Uyumlu Panolar ve Erişim: AWS CloudWatch panoları, web tabanlı arayüzleri sayesinde varsayılan olarak mobil cihazlarda da görüntülenebilir. Ancak, daha iyi bir kullanıcı deneyimi için, panoları mobil ekran boyutlarına optimize etmek önemlidir. CloudWatch panolarındaki widget'ların yerleşimini ve boyutunu, farklı ekran çözünürlüklerinde kolayca okunabilecek şekilde tasarlayabilirsiniz. Ayrıca, AWS Mobil Uygulaması üzerinden CloudWatch panolarınıza ve alarmlarınıza erişerek hareket halindeyken bile altyapınızın durumu hakkında bilgi sahibi olabilirsiniz. HTML bazlı özel panolar geliştiriyorsanız, mutlaka etiketini kullanmalı ve CSS media query'leri ile duyarlı tasarım (responsive design) ilkelerini uygulamalısınız. Örneğin, daha küçük ekranlarda metrik grafiklerini alt alta yerleştirmek veya daha az bilgi göstermek, mobil kullanılabilirliği artıracaktır.

    Bu ileri düzey teknikler ve en iyi uygulamalar, Hetzner ve AWS kaynaklarınızı izleme yeteneğinizi önemli ölçüde güçlendirecek ve operasyonel süreçlerinizi daha sağlam, verimli ve güvenli hale getirecektir. Unutmayın, izleme sürekli bir süreçtir ve altyapınız geliştikçe izleme stratejinizin de gelişmesi gerekir.

    Sonuç: Hibrit Bulut İzlemede Güçlü Bir Sinerji

    Bu kapsamlı rehber boyunca, Hetzner Cloud kaynaklarını AWS CloudWatch'un güçlü izleme yetenekleriyle entegre etmenin ve bu süreci Terraform ile otomatize etmenin tüm adımlarını detaylı bir şekilde inceledik. Modern IT dünyasının kaçınılmaz bir gerçeği olan hibrit bulut ortamlarında, farklı platformlardaki altyapı bileşenlerini tek bir merkezi noktadan izleyebilmek, operasyonel verimlilik ve hızlı olay müdahalesi için vazgeçilmezdir.

    Hetzner'ın rekabetçi fiyatlandırma ve yüksek performans avantajları ile AWS CloudWatch'un geniş izleme, alarm ve görselleştirme yeteneklerini bir araya getirmek, işletmeler için kritik bir sinerji yaratmaktadır. Terraform'un "altyapı kod olarak" yaklaşımı sayesinde, bu entegrasyonun dağıtımı, güncellenmesi ve sürüm kontrolü altında tutulması kolaylaşmış, manuel hatalar en aza indirilmiş ve tekrarlanabilir, güvenilir bir izleme altyapısı inşa edilmiştir. Metrik toplama için AWS Lambda ve EventBridge'ın kullanımı ise, sunucusuz bir yaklaşım sunarak operasyonel yükü azaltmış ve maliyet etkinliğini artırmıştır.

    Kurulan bu merkezi izleme sistemi sayesinde, Hetzner sunucularınızdaki CPU, bellek, ağ trafiği gibi kritik performans göstergelerini tek bir CloudWatch panosundan takip edebilir, belirlenen eşiklerin aşılması durumunda anında bildirimler alabilirsiniz. Bu, potansiyel sorunları proaktif olarak tespit etmenize, kesinti sürelerini kısaltmanıza ve genel sistem sağlığını iyileştirmenize olanak tanır. İleri düzey anomali tespiti, kapsamlı log yönetimi ve güvenlik odaklı yaklaşımlarla bu temel entegrasyonu daha da güçlendirebilirsiniz. Unutmayın, iyi bir izleme stratejisi, sadece sorunları tespit etmekle kalmaz, aynı zamanda altyapınızın gelecekteki büyüme ve gelişimi için de değerli içgörüler sunar.

    Sıkça Sorulan Sorular

    1. Hetzner Cloud doğrudan CloudWatch'a metrik gönderme özelliği sunuyor mu?

      Hayır, Hetzner Cloud, AWS CloudWatch ile doğrudan bir entegrasyon sunmamaktadır. Bu makalede anlatıldığı gibi, metriklerinizi özel betikler veya ajanlar aracılığıyla toplayıp CloudWatch'a göndermeniz gerekir.

    2. Bu entegrasyonun maliyeti ne olur?

      Maliyet, gönderdiğiniz metriklerin hacmine (Custom Metrics), Lambda fonksiyonunun çalışma sıklığına ve süresine, CloudWatch alarmlarının ve panolarının sayısına bağlıdır. AWS'nin Ücretsiz Katmanı'ndan faydalanarak başlangıçta maliyetleri düşürebilirsiniz. Genellikle, metrik başına düşük bir ücretlendirme yapılır ve Lambda gibi sunucusuz hizmetler için sadece kullandığınız kadar ödersiniz.

    3. Hetzner sunucularımın tüm metriklerini CloudWatch'a gönderebilir miyim?

      Evet, teorik olarak Hetzner sunucularınızdan alabileceğiniz her türlü metrik (CPU, RAM, disk I/O, ağ trafiği, uygulama metrikleri vb.) özel betikler veya üçüncü taraf ajanlar (örneğin Prometheus Node Exporter) aracılığıyla toplanıp CloudWatch'a özel metrik olarak gönderilebilir. Önemli olan, bu verileri doğru formatta toplayıp CloudWatch'un PutMetricData API'sine göndermektir.

    4. Bu kurulumda güvenlik endişeleri nelerdir?

      En büyük güvenlik endişeleri API anahtarlarının (Hetzner ve AWS) yönetimidir. Bu anahtarları hiçbir zaman açık metin olarak depolamayın. AWS IAM rolleri ve politikaları ile en düşük ayrıcalık ilkesini uygulayın. Hetzner API anahtarınızı AWS Secrets Manager gibi güvenli bir hizmette saklayın ve Lambda fonksiyonu tarafından çalışma zamanında erişilmesini sağlayın. Ayrıca, Lambda fonksiyonuna yalnızca CloudWatch'a metrik gönderme ve log yazma izni verin.

    5. Terraform ile yapılan bu yapılandırmayı nasıl yönetirim?

      Terraform state dosyasını güvenli bir şekilde (örneğin AWS S3'te uzaktan depolama ve DynamoDB ile kilitleme) yöneterek ekip içinde tutarlı ve güvenli bir altyapı yönetimi sağlayabilirsiniz. Versiyon kontrolü (Git) kullanarak kodunuzu takip edin ve değişiklikleri gözden geçirin. Her değişiklik öncesinde terraform plan komutunu kullanarak beklenen değişiklikleri gözden geçirmek iyi bir uygulamadır.

byFatih Soysal
0
Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Aşağıdaki içerikler de ilgilinizi çekebilir:

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.