Elastic Cloud ve Deployment Seçenekleri

Giriş — Ev mi, Kiralık mı, Apart mı?

Bir ev arıyorsun. Seçeneklerin var: Kendi evini kendin yap (self-managed), hazır bir apartman dairesi kirala (Elastic Cloud), kendi arsana müteahhit çağır (ECE on-prem), veya akıllı bir bina yönetim sistemiyle birden fazla daire yönet (ECK on Kubernetes). Her birinin maliyeti, esnekliği ve baş ağrısı farklı.

Elasticsearch dünyasında da aynı. Production'a giderken "nerede çalıştıracağım?" sorusunun cevabı, şirketinin büyüklüğüne, bütçesine, compliance ihtiyaçlarına ve ekip kapasitesine göre değişir. Bu derste tüm deployment seçeneklerini, avantaj-dezavantajlarıyla, maliyet karşılaştırmasıyla ve "ne zaman hangisi" rehberiyle göreceğiz.

1. Elastic Cloud (ESS) — Managed Service

ESS Nedir?

Elastic Cloud (Elasticsearch Service — ESS), Elastic şirketinin resmi bulut hizmetidir. AWS, GCP ve Azure üzerinde çalışır. Altyapı yönetimini Elastic halleder, sen sadece kullanırsın.

SEN:
├── Veri gönder
├── Sorgu yaz
├── Dashboard oluştur
└── Monitoring izle

ELASTIC:
├── Cluster kur
├── OS güncelle
├── ES güncelle
├── Backup al
├── HA sağla
├── Scaling yap
├── Güvenlik yönet
└── 7/24 destek

ESS Özellikleri

Deployment Oluşturma

Elastic Cloud Console (cloud.elastic.co)

1. Create deployment
2. Cloud provider: AWS / GCP / Azure
3. Region: eu-west-1 (Ireland)
4. Hardware profile:
   - General Purpose (dengeli)
   - Storage Optimized (log analytics)
   - CPU Optimized (arama ağırlıklı)
   - Hot-Warm-Cold (time-series)

5. Elasticsearch:
   - RAM: 8 GB (4 GB × 2 zone)
   - Disk: 240 GB
   - Zones: 2 (HA)

6. Kibana:
   - RAM: 1 GB
   - Zone: 1

7. Optional:
   - APM & Fleet: 0.5 GB
   - Enterprise Search: 2 GB
   - ML node: 4 GB

Deployment Templates

ESS, yaygın kullanım senaryoları için hazır template'ler sunar:

Autoscaling

ESS autoscaling, iki yönde çalışır:

Data tier autoscaling:
├── Shard boyutu büyüdükçe → Disk otomatik artar
├── Shard sayısı arttıkça → RAM otomatik artar
└── Disk watermark'a yaklaşınca → Uyarı + auto-scale

ML autoscaling:
├── ML job başlatılınca → ML node otomatik oluşur
├── ML job bitince → ML node kapanır (maliyet tasarrufu)
└── Anomaly detection + NLP modelleri

// Autoscaling durumunu kontrol et (API)
GET _autoscaling/capacity

// Çıktı:
// {
//   "policies": {
//     "hot": {
//       "required_capacity": {
//         "node": { "storage": "240gb", "memory": "8gb" },
//         "total": { "storage": "480gb", "memory": "16gb" }
//       },
//       "current_capacity": {
//         "node": { "storage": "240gb", "memory": "8gb" },
//         "total": { "storage": "480gb", "memory": "16gb" }
//       }
//     }
//   }
// }

Traffic Filtering

ESS'te cluster'ınıza kimlerin erişebileceğini kontrol edebilirsiniz:

Cloud Console → Deployment → Security → Traffic filters

IP filtering:
- Allow: 203.0.113.0/24 (ofis IP aralığı)
- Allow: 10.0.0.0/8 (VPC)
- Deny: all others

VPC/VNet peering:
- AWS VPC endpoint
- Azure Private Link
- GCP Private Service Connect

ESS Fiyatlandırma

Fiyatlandırma = RAM × Saat × Birim Fiyat

Örnek (2024 yaklaşık fiyatlar, AWS eu-west-1):

Elasticsearch:
  Hot:    $0.316/GB-RAM/saat ≈ $231/GB-RAM/ay
  Warm:   $0.158/GB-RAM/saat ≈ $115/GB-RAM/ay
  Cold:   Snapshot storage maliyeti

Kibana:   $0.316/GB-RAM/saat
APM:      $0.316/GB-RAM/saat

ÖRNEK DEPLOYMENT:
  ES Hot:   8 GB RAM × $231/ay = $1,848/ay
  ES Warm:  4 GB RAM × $115/ay = $460/ay
  Kibana:   1 GB RAM × $231/ay = $231/ay
  APM:      0.5 GB × $231/ay  = $116/ay
  ───────────────────────────────────
  TOPLAM:   ≈ $2,655/ay (disk dahil)

NOT: Fiyatlar region ve provider'a göre değişir.
     Yıllık commit ile %10-20 indirim mümkün.
     Enterprise lisans ayrı faturalıdır.

2. ECE — Elastic Cloud Enterprise (On-Prem)

ECE Nedir?

ECE, Elastic Cloud deneyimini kendi veri merkezinizde çalıştırmanızı sağlar. Birden fazla Elasticsearch cluster'ını tek bir kontrol panelinden yönetirsiniz.

ECE Mimarisi:

┌──────────────────────────────────────────────────┐
│                ECE Admin Console                  │
│  Deployment yönetimi, monitoring, kullanıcılar    │
├──────────────────────────────────────────────────┤
│              ECE Coordinator                      │
│  Scheduling, health checks, auto-repair           │
├───────────┬──────────┬───────────┬───────────────┤
│   Host 1  │  Host 2  │  Host 3   │   Host N      │
│ ┌───────┐ │┌───────┐ │ ┌───────┐ │ ┌───────┐     │
│ │Deploy1│ ││Deploy1│ │ │Deploy2│ │ │Deploy3│     │
│ │ES node│ ││ES node│ │ │ES node│ │ │ES node│     │
│ └───────┘ │└───────┘ │ └───────┘ │ └───────┘     │
│ ┌───────┐ │┌───────┐ │ ┌───────┐ │               │
│ │Deploy2│ ││Kibana │ │ │Deploy3│ │               │
│ │ES node│ ││       │ │ │ES node│ │               │
│ └───────┘ │└───────┘ │ └───────┘ │               │
└───────────┴──────────┴───────────┴───────────────┘

ECE Kullanım Senaryoları

• Veri egemenliği: Verinin ülke dışına çıkmaması gereken durumlar (KVKK, GDPR)

• Air-gapped ortamlar: İnternet erişimi olmayan güvenlik ortamları

• Multi-tenant: İç müşterilere ayrı ayrı cluster'lar sunma

• Maliyet optimizasyonu: Büyük ölçekte bulut maliyetinden kaçınma

ECE Kurulum Gereksinimleri

Minimum Production Kurulumu:

Host 1 (Coordinator + Allocator):
  - 128 GB RAM
  - 32 core CPU
  - 1 TB SSD
  - OS: Ubuntu 20.04+ / CentOS 7+ / RHEL 7+

Host 2 (Allocator):
  - 128 GB RAM
  - 32 core CPU
  - 1 TB SSD

Host 3 (Allocator):
  - 128 GB RAM
  - 32 core CPU
  - 1 TB SSD

Toplam Minimum: 3 host, 384 GB RAM, 96 core CPU, 3 TB SSD

# ECE kurulumu (basitleştirilmiş)
# 1. Docker gerekli
curl -fsSL https://get.docker.com | sh

# 2. ECE installer'ı indir
curl -L -O https://download.elastic.co/cloud/elastic-cloud-enterprise.sh
chmod +x elastic-cloud-enterprise.sh

# 3. İlk host'u kur (coordinator + allocator)
./elastic-cloud-enterprise.sh install \
  --coordinator-host \
  --allocator-host \
  --availability-zone zone-1

# 4. Diğer host'ları ekle
./elastic-cloud-enterprise.sh install \
  --allocator-host \
  --availability-zone zone-2 \
  --coordinator-host coordinator-ip

ECE vs ESS Karşılaştırma

3. ECK — Elastic Cloud on Kubernetes

ECK Nedir?

ECK (Elastic Cloud on Kubernetes), Kubernetes üzerinde Elasticsearch cluster'larını yönetmek için resmi Kubernetes Operator'üdür.

ECK Operator ne yapar?
├── Custom Resource Definition (CRD) ile ES cluster tanımlama
├── StatefulSet, Service, ConfigMap otomatik oluşturma
├── Rolling upgrade
├── Scaling (horizontal + vertical)
├── TLS sertifika yönetimi (otomatik)
├── Backup (snapshot) yönetimi
└── Monitoring

ECK Kurulumu

# 1. ECK Operator kur
kubectl create -f https://download.elastic.co/downloads/eck/2.11.1/crds.yaml
kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/operator.yaml

# Operator çalışıyor mu?
kubectl -n elastic-system get pods
# NAME                 READY   STATUS    RESTARTS   AGE
# elastic-operator-0   1/1     Running   0          1m

Elasticsearch Cluster CRD

# elasticsearch.yaml
apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: production-es
  namespace: elastic
spec:
  version: 8.12.0
  
  # Node sets (tier mimarisi)
  nodeSets:
    # Hot tier
    - name: hot
      count: 3
      config:
        node.roles: ["master", "data_hot", "ingest"]
        node.store.allow_mmap: false
      podTemplate:
        spec:
          containers:
            - name: elasticsearch
              resources:
                requests:
                  memory: 8Gi
                  cpu: 4
                limits:
                  memory: 8Gi
                  cpu: 4
              env:
                - name: ES_JAVA_OPTS
                  value: "-Xms4g -Xmx4g"
          # Node affinity — hot node'ları SSD disk'li node'lara yerleştir
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                  - matchExpressions:
                      - key: disk-type
                        operator: In
                        values: ["ssd"]
      volumeClaimTemplates:
        - metadata:
            name: elasticsearch-data
          spec:
            accessModes: ["ReadWriteOnce"]
            storageClassName: fast-ssd
            resources:
              requests:
                storage: 500Gi
    
    # Warm tier
    - name: warm
      count: 2
      config:
        node.roles: ["data_warm"]
      podTemplate:
        spec:
          containers:
            - name: elasticsearch
              resources:
                requests:
                  memory: 4Gi
                  cpu: 2
                limits:
                  memory: 4Gi
                  cpu: 2
              env:
                - name: ES_JAVA_OPTS
                  value: "-Xms2g -Xmx2g"
      volumeClaimTemplates:
        - metadata:
            name: elasticsearch-data
          spec:
            accessModes: ["ReadWriteOnce"]
            storageClassName: standard-hdd
            resources:
              requests:
                storage: 2Ti

  # HTTP configuration
  http:
    tls:
      selfSignedCertificate:
        disabled: false
    service:
      spec:
        type: LoadBalancer

Kibana CRD

# kibana.yaml
apiVersion: kibana.k8s.elastic.co/v1
kind: Kibana
metadata:
  name: production-kibana
  namespace: elastic
spec:
  version: 8.12.0
  count: 2  # HA için 2 replica
  elasticsearchRef:
    name: production-es
  http:
    service:
      spec:
        type: LoadBalancer
  podTemplate:
    spec:
      containers:
        - name: kibana
          resources:
            requests:
              memory: 1Gi
              cpu: 1
            limits:
              memory: 2Gi
              cpu: 2

APM Server CRD

# apm-server.yaml
apiVersion: apm.k8s.elastic.co/v1
kind: ApmServer
metadata:
  name: production-apm
  namespace: elastic
spec:
  version: 8.12.0
  count: 2
  elasticsearchRef:
    name: production-es
  kibanaRef:
    name: production-kibana
  http:
    service:
      spec:
        type: ClusterIP

# Tüm kaynakları uygula
kubectl apply -f elasticsearch.yaml
kubectl apply -f kibana.yaml
kubectl apply -f apm-server.yaml

# Durumu kontrol et
kubectl -n elastic get elasticsearch,kibana,apmserver

# NAME                                    HEALTH   NODES   VERSION   PHASE   AGE
# elasticsearch.../production-es          green    5       8.12.0    Ready   5m
# kibana.../production-kibana             green    2       8.12.0    Ready   3m
# apmserver.../production-apm             green    2       8.12.0    Ready   2m

# ES erişim bilgileri
kubectl -n elastic get secret production-es-es-elastic-user -o jsonpath='{.data.elastic}' | base64 -d

ECK Scaling

# Horizontal scaling — node sayısını artır
kubectl -n elastic patch elasticsearch production-es --type merge -p '
{
  "spec": {
    "nodeSets": [
      {
        "name": "hot",
        "count": 5
      }
    ]
  }
}'

# ECK otomatik olarak:
# 1. Yeni pod'ları oluşturur
# 2. ES cluster'a ekler
# 3. Shard rebalancing bekler
# 4. Ready durumuna geçer

ECK Upgrade

# Version upgrade — ECK rolling upgrade yönetir
kubectl -n elastic patch elasticsearch production-es --type merge -p '
{
  "spec": {
    "version": "8.13.0"
  }
}'

# ECK otomatik olarak:
# 1. Pod'ları birer birer yeniden oluşturur
# 2. Shard allocation'ı yönetir
# 3. Health check yapar
# 4. Sorun varsa durdurur

4. Self-Managed — Docker Compose, Ansible, Helm

Docker Compose ile Kurulum

# docker-compose.yml — 3 node ES cluster
version: '3.8'

services:
  es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    container_name: es01
    environment:
      - node.name=es01
      - cluster.name=production
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - node.roles=master,data_hot,ingest
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
      - xpack.security.enabled=true
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.http.ssl.enabled=true
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es01-data:/usr/share/elasticsearch/data
      - ./certs:/usr/share/elasticsearch/config/certs:ro
    ports:
      - "9200:9200"
    networks:
      - elastic
    deploy:
      resources:
        limits:
          memory: 8G

  es02:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    container_name: es02
    environment:
      - node.name=es02
      - cluster.name=production
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - node.roles=master,data_hot,ingest
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
      - xpack.security.enabled=true
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.http.ssl.enabled=true
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es02-data:/usr/share/elasticsearch/data
      - ./certs:/usr/share/elasticsearch/config/certs:ro
    networks:
      - elastic
    deploy:
      resources:
        limits:
          memory: 8G

  es03:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    container_name: es03
    environment:
      - node.name=es03
      - cluster.name=production
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=es01,es02,es03
      - node.roles=master,data_hot,ingest
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
      - xpack.security.enabled=true
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.http.ssl.enabled=true
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es03-data:/usr/share/elasticsearch/data
      - ./certs:/usr/share/elasticsearch/config/certs:ro
    networks:
      - elastic
    deploy:
      resources:
        limits:
          memory: 8G

  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.0
    container_name: kibana
    environment:
      - ELASTICSEARCH_HOSTS=https://es01:9200
      - ELASTICSEARCH_USERNAME=kibana_system
      - ELASTICSEARCH_PASSWORD=changeme
    ports:
      - "5601:5601"
    networks:
      - elastic
    depends_on:
      - es01
      - es02
      - es03

volumes:
  es01-data:
  es02-data:
  es03-data:

networks:
  elastic:
    driver: bridge

# Başlat
docker-compose up -d

# Logları izle
docker-compose logs -f es01

# Durdur
docker-compose down

# Veriyi koruyarak durdur
docker-compose down  # (volumes silinmez)

# Veriyle birlikte sil
docker-compose down -v  # (DİKKAT: Veri silinir!)

Ansible ile Kurulum

# playbook.yml — Elasticsearch cluster kurulumu
---
- name: Elasticsearch Cluster Setup
  hosts: elasticsearch_nodes
  become: yes
  
  vars:
    es_version: "8.12.0"
    es_heap_size: "4g"
    cluster_name: "production"
  
  tasks:
    - name: Import Elastic GPG key
      rpm_key:
        key: https://artifacts.elastic.co/GPG-KEY-elasticsearch
        state: present

    - name: Add Elastic repository
      yum_repository:
        name: elastic-8.x
        description: Elastic 8.x Repository
        baseurl: https://artifacts.elastic.co/packages/8.x/yum
        gpgkey: https://artifacts.elastic.co/GPG-KEY-elasticsearch
        gpgcheck: yes

    - name: Install Elasticsearch
      yum:
        name: "elasticsearch-{{ es_version }}"
        state: present

    - name: Configure Elasticsearch
      template:
        src: elasticsearch.yml.j2
        dest: /etc/elasticsearch/elasticsearch.yml
        owner: elasticsearch
        group: elasticsearch
      notify: restart elasticsearch

    - name: Configure JVM options
      template:
        src: jvm.options.j2
        dest: /etc/elasticsearch/jvm.options.d/heap.options
      notify: restart elasticsearch

    - name: Set vm.max_map_count
      sysctl:
        name: vm.max_map_count
        value: "262144"
        state: present
        reload: yes

    - name: Start and enable Elasticsearch
      systemd:
        name: elasticsearch
        state: started
        enabled: yes

  handlers:
    - name: restart elasticsearch
      systemd:
        name: elasticsearch
        state: restarted

Helm Chart ile Kubernetes Kurulumu (ECK Olmadan)

# Elastic Helm repo ekle
helm repo add elastic https://helm.elastic.co
helm repo update

# Elasticsearch kur
helm install elasticsearch elastic/elasticsearch \
  --namespace elastic \
  --create-namespace \
  --set replicas=3 \
  --set minimumMasterNodes=2 \
  --set resources.requests.memory=4Gi \
  --set resources.limits.memory=4Gi \
  --set volumeClaimTemplate.resources.requests.storage=500Gi \
  --set persistence.enabled=true

# Kibana kur
helm install kibana elastic/kibana \
  --namespace elastic \
  --set elasticsearchHosts="http://elasticsearch-master:9200"

5. Maliyet Karşılaştırma

10 TB Veri, 30 Gün Retention Senaryosu

Gereksinimler:
- 333 GB/gün indexing
- 10 TB hot (30 gün)
- Standart arama yükü
- HA (en az 2 zone)

═══════════════════════════════════════

ESS (Elastic Cloud):
  Hot: 16 GB RAM × 2 zone = $7,392/ay
  Disk: ~15 TB SSD (otomatik)
  Kibana: 2 GB = $462/ay
  Toplam: ~$8,000-10,000/ay
  
  ✅ Sıfır ops overhead
  ✅ Otomatik backup, upgrade
  ❌ En pahalı seçenek

═══════════════════════════════════════

ECE (On-Prem):
  Donanım (3 yıl amortisman):
    6 sunucu × $15,000 = $90,000 / 36 ay = $2,500/ay
  Lisans: Platinum ~$2,000-4,000/ay (node sayısına göre)
  Hosting/elektrik/ağ: ~$1,000/ay
  Ops personeli: ~$2,000/ay (yarı zamanlı DevOps)
  Toplam: ~$7,500-9,500/ay
  
  ✅ Veri egemenliği
  ✅ Uzun vadede ucuz (3+ yıl)
  ❌ Ops overhead yüksek
  ❌ İlk yatırım büyük

═══════════════════════════════════════

ECK (Kubernetes):
  Kubernetes cluster (AWS EKS):
    6 × m5.2xlarge (32GB, 8 core) = ~$3,600/ay
  EBS storage: 15 TB × $0.10/GB = $1,500/ay
  EKS kontrol plane: $72/ay
  Lisans: Basic (ücretsiz) veya Platinum
  Toplam: ~$5,200-8,200/ay (lisansa göre)
  
  ✅ K8s zaten varsa entegre
  ✅ ECK operator ile kolay yönetim
  ❌ K8s bilgisi gerekli
  ❌ Stateful workload K8s'te zor

═══════════════════════════════════════

Self-Managed (Docker/Ansible):
  Cloud VM (AWS EC2):
    6 × m5.2xlarge = ~$3,600/ay
  EBS: 15 TB = $1,500/ay
  Ops: ~$3,000/ay (DevOps zamanı)
  Lisans: Basic (ücretsiz)
  Toplam: ~$5,100-8,100/ay
  
  ✅ En esnek
  ✅ Basic lisans ücretsiz
  ❌ En fazla ops overhead
  ❌ Upgrade, backup, HA hep elle

Karar Matrisi

6. Ne Zaman Hangisi?

Karar Ağacı

Elasticsearch nerede çalıştıracağız?
│
├── Veri ülke dışına çıkabilir mi?
│   ├── HAYIR → On-prem gerekli
│   │   ├── Kubernetes var mı?
│   │   │   ├── EVET → ECK
│   │   │   └── HAYIR → ECE veya Self-managed
│   │   └── Multi-tenant gerekli mi?
│   │       ├── EVET → ECE
│   │       └── HAYIR → Self-managed
│   │
│   └── EVET → Cloud'a devam
│       ├── Ops ekibi var mı?
│       │   ├── HAYIR → ESS (Elastic Cloud) ✅
│       │   └── EVET
│       │       ├── Kubernetes var mı?
│       │       │   ├── EVET → ECK
│       │       │   └── HAYIR → ESS veya Self-managed
│       │       └── Bütçe kısıtı var mı?
│       │           ├── EVET → Self-managed (Basic lisans)
│       │           └── HAYIR → ESS
│
└── Prototiping / PoC?
    └── EVET → ESS (14 gün ücretsiz trial) veya Docker Compose

Pratik Tavsiyeler

STARTUP / KÜÇÜK EKİP:
→ ESS (Elastic Cloud)
→ Ops ile uğraşma, ürüne odaklan
→ Trial ile başla, büyüdükçe ölçekle

ORTA ÖLÇEKLİ ŞİRKET:
→ ESS veya ECK (K8s zaten varsa)
→ Maliyet-performans dengesi için ECK iyi
→ DevOps ekibi varsa self-managed da olur

BÜYÜK ENTERPRISE:
→ ECE (veri egemenliği + multi-tenant)
→ veya ESS Enterprise (tam yönetilen)
→ Hybrid: Hassas veri on-prem (ECE), 
  geri kalan cloud (ESS)

FİNANS / SAVUNMA / SAĞLIK:
→ ECE veya air-gapped self-managed
→ Compliance gereksinimleri belirler
→ Veri asla cloud'a çıkmayabilir

Özet

Bu derste öğrendiklerimizi toplayalım:

1. Elastic Cloud (ESS), tam yönetilen SaaS çözümüdür. AWS/GCP/Azure üzerinde çalışır, autoscaling, otomatik backup, 1-click upgrade sunar. Ops overhead sıfıra yakındır — startup ve küçük ekipler için ideal.

2. ECE (Elastic Cloud Enterprise), Elastic Cloud deneyimini kendi veri merkezinize getirir. Multi-tenant, air-gap desteği, veri egemenliği sağlar. Minimum 3 host, 384 GB RAM gerektirir.

3. ECK (Elastic Cloud on Kubernetes), Kubernetes operator ile ES cluster'larını CRD olarak tanımlar. Rolling upgrade, auto-scaling, TLS yönetimi otomatiktir. K8s zaten kullanıyorsanız doğal seçim.

4. Self-managed (Docker Compose, Ansible, Helm), en esnek ama en fazla ops gerektiren seçenektir. Basic lisans ücretsizdir. Küçük ekiplerden çok, deneyimli DevOps ekipleri için uygundur.

5. Maliyet karşılaştırması use case'e göre değişir. ESS en pahalı ama en az ops gerektirir. Self-managed en ucuz ama en fazla zaman yatırımı ister. 3+ yıllık perspektifte on-prem (ECE) büyük ölçekte ekonomik olabilir.

6. Karar kriteri: Veri egemenliği, bütçe, ekip kapasitesi ve mevcut altyapı (K8s var mı?) soruları, doğru seçeneği belirler.