Docker ile Web Uygulaması Deploy: Dockerfile, Compose ve Production Rehberi

Docker ile Web Uygulaması Deploy: Dockerfile, Compose ve Production

Docker, "bende çalışıyor ama sunucuda çalışmıyor" sorununu ortadan kaldıran platform cümlesinin ötesinde bir şeydir: uygulamayı bağımlılıklarıyla birlikte bir araya getiren image sistemi, bu image'dan tekrarlanabilir biçimde doğan container'lar ve bunları bir arada çalıştıran Compose (veya Swarm) katmanı. Bu yazıda Dockerfile yazımından multi-stage build'e, docker-compose yapılandırmasından production reverse proxy kurulumuna, volume yönetiminden güvenlik pratiklerine kadar Docker'ın web uygulaması deploy döngüsünü ele alıyoruz.

Buyukweb bağlamı: Buyukweb VDS sunucuları KVM sanallaştırmasıyla gelir; Docker, KVM içinde ek bir ayar gerektirmeden (nested virtualization'a ihtiyaç duymadan) çalışır. Minimum 2 vCPU + 4 GB RAM olan bir VDS, Node.js + Postgres + Nginx gibi üç servisli bir Compose stack'i için yeterli başlangıç noktasıdır. cPanel paylaşımlı hosting paketlerinde root erişimi bulunmadığından Docker desteklenmez; Docker için doğru seçenek VDS'tir.

Container ile VM Arasındaki Fark: Namespace ve Cgroups

VM, bir donanım katmanını taklit eder ve tam bir işletim sistemi çalıştırır; container ise host kernel'ini paylaşır, yalnızca kullanıcı alanını izole eder. İzolasyon iki Linux çekirdeği özelliğiyle sağlanır:

• Namespace: Her container için ayrı PID alanı, ağ arayüzü, mount noktası, UTS (hostname) ve IPC kuyruğu oluşturur. Bir container içindeki süreçler birbirini görebilir ama host veya diğer container'ların süreçlerini göremez.
• Cgroups: CPU, bellek, disk I/O ve ağ bant genişliği üzerinde kaynak limitleri belirler. Container'ın hafızası dolduğunda host'u çökertmek yerine yalnızca o container OOMKilled edilir.

Bu mimari VM'e kıyasla başlatma süresini saniyelerden milisaniyelere indirir ve aynı donanımda çok daha fazla izole servis çalıştırmayı mümkün kılar.

Docker Engine vs Podman vs containerd: Docker Engine, containerd runtime'ını kullanan bir üst katman daemon'dır. Podman, daemon gerektirmeyen ve rootless modda çalışabilen bir alternatiftir; CLI uyumluluğu yüksektir. containerd ise Kubernetes'in de kullandığı düşük seviyeli runtime'dır. Küçük-orta ekip ve Buyukweb VDS senaryosunda Docker Engine + Compose kombinasyonu en doğrudan yoldur.

Docker Kurulumu: Ubuntu ve AlmaLinux

Paket yöneticisi üzerinden doğrudan docker.io kurmak yerine Docker'ın resmi docker-ce deposunu ekleyip oradan kurun; bu sayede güncel sürümü ve docker-compose-plugin'i alırsınız.

Ubuntu 22.04 / 24.04

apt update
apt install -y ca-certificates curl gnupg
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg   | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg]   https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable"   | tee /etc/apt/sources.list.d/docker.list

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
systemctl enable --now docker

AlmaLinux 9 / CentOS Stream

dnf install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
dnf install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
systemctl enable --now docker

Sürüm Doğrulaması

docker --version          # Docker version 26.x
docker compose version    # Docker Compose version v2.x

Docker Desktop, macOS/Windows'ta yerel geliştirme için kullanılır; Linux VDS üzerinde ihtiyaç yoktur.

Image, Container, Volume ve Network Kavramları

Dört temel kavramı anlamadan Compose dosyası yazmak güçtür:

• Image: Okunabilir katmanlardan (layer) oluşan ve uygulamayı + bağımlılıklarını içeren şablondur. Docker Hub, GitHub Container Registry (GHCR) ve Harbor gibi registry'lerde depolanır.
• Container: Image'dan doğan, çalışır durumda bir süreçtir. Durduğunda veri tutmaz (kök dosya sistemi silinir); kalıcı veri için Volume kullanılır.
• Volume: Container bağımsız kalıcı depolamadır. Named volume Docker tarafından yönetilir; bind mount host dizinini doğrudan container'a bağlar.
• Network: Container'ların birbirine hostname:port yerine servis adı üzerinden ulaştığı sanal ağdır. Compose varsayılan olarak her proje için ayrı bir bridge ağı oluşturur.

Dockerfile Temel Yazımı

Node.js uygulaması için temel Dockerfile:

FROM node:20-alpine

WORKDIR /app

# Önce bağımlılık dosyalarını kopyala (layer cache için)
COPY package*.json ./
RUN npm ci --only=production

# Kaynak kodu sonra kopyala
COPY . .

EXPOSE 3000

# Dizi formu (shell özelliği gerekmediğinde tercih)
CMD ["node", "server.js"]

ENTRYPOINT vs CMD: ENTRYPOINT sabit yürütücüyü belirtir (["node"]), CMD varsayılan argümanı sağlar (["server.js"]). İkisi birlikte kullanılınca docker run satırından argüman geçmek kolaylaşır. Yalnızca CMD yeterli olduğu durumlarda ayrıca ENTRYPOINT eklemeye gerek yoktur.

Multi-Stage Build ile Image Küçültme

Build bağımlılıklarını (derleyici, geliştirme araçları) çalışma zamanı image'ına taşımamak için multi-stage build kullanın:

# Aşama 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Aşama 2: Runtime (sadece üretim için gerekli dosyalar)
FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/.next ./.next
COPY --from=builder /app/public ./public
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["npm", "start"]

Next.js için bu pattern çoğunlukla 1 GB'ı aşan builder image yerine 200-300 MB civarında bir runtime image üretir.

Layer Cache Stratejisi ve .dockerignore

Docker her Dockerfile komutunu bir katman olarak saklar. Bir katman değiştiğinde sonraki tüm katmanlar yeniden çalışır. Bu nedenle değişim sıklığı düşük içerikler (bağımlılık dosyaları) önce, sık değişen kaynak kodu sonra kopyalanmalıdır:

COPY package*.json ./   # Sadece package.json değişince bu katman geçersiz olur
RUN npm ci              # Bağımlılıklar cache'ten gelir
COPY . .                # Kaynak değişince yalnızca bu katman yeniden çalışır

.dockerignore dosyası gereksiz dosyaların image'a girmesini ve build context'in şişmesini önler:

node_modules
.git
.env
*.log
.next
dist
coverage

Image Best Practice: Alpine, Non-Root Kullanıcı ve Health Check

Alpine vs Debian/Distroless: node:20-alpine küçüktür (~50 MB) ve saldırı yüzeyi dardır. Bazı native modüller (ImageMagick bağımlıları gibi) Alpine'de derleme sorunu yaşatabilir; bu durumda node:20-slim (Debian tabanlı, daha büyük ama uyumlu) tercih edin. Distroless image'lar shell içermez — debug zordur ama en dar saldırı yüzeyini sunar.

Non-root kullanıcı: Container varsayılan olarak root çalışır; bu bir güvenlik açığıdır. Node.js resmi image'ı zaten node kullanıcısını içerir:

# Root olarak kur
RUN npm ci --only=production

# Üretimde node kullanıcısına geç
USER node
CMD ["node", "server.js"]

HEALTHCHECK: Orchestrator'a container'ın gerçekten hazır olup olmadığını bildirin:

HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3   CMD wget -qO- http://localhost:3000/api/health || exit 1

OCI Labels: Image meta verisini standart OCI etiketleriyle belgeleyin:

LABEL org.opencontainers.image.title="Buyukweb App"       org.opencontainers.image.version="1.0.0"       org.opencontainers.image.source="https://github.com/buyukweb/app"

docker-compose.yml: Çok Servisli Uygulama

2024 itibarıyla geçerli format Compose Spec'tir (version: alanı artık zorunlu değil, belirtilse de görmezden gelinir). Node.js + Postgres + Nginx üçlüsü için örnek:

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    environment:
      NODE_ENV: production
      DATABASE_URL: postgresql://dbuser:SIFRE@db:5432/uygulama
    volumes:
      - uploads:/app/uploads
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/health"]
      interval: 30s
      timeout: 5s
      retries: 3

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: dbuser
      POSTGRES_PASSWORD: SIFRE
      POSTGRES_DB: uygulama
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dbuser -d uygulama"]
      interval: 10s
      timeout: 5s
      retries: 5

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - app

volumes:
  pgdata:
  uploads:

Temel Compose komutları:

docker compose up -d            # Arkaplanda başlat
docker compose down             # Durdur; volume'lar korunur
docker compose down -v          # Volume'ları da sil (DİKKAT)
docker compose logs -f app      # Canlı log
docker compose ps               # Servis durumları
docker compose exec app sh      # Container içine gir
docker compose pull             # Image'ları güncelle
docker compose up -d --build    # Yeniden build edip başlat

restart policy: no (varsayılan, her zaman el ile başlat), always (host reboot dahil her koşulda), on-failure (sadece sıfır-dışı çıkış kodu), unless-stopped (elle stop edilmediğinde her zaman — production için bu tercih edilir).

Volume Yönetimi: Named Volume, Bind Mount ve Backup

Named volume (önerilen): Docker yönetir, veri /var/lib/docker/volumes/ altında tutulur, container silinse de veri kalır.

Bind mount: Host dizinini container içine bağlar (./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro); konfigürasyon dosyaları ve sertifikalar için uygundur.

tmpfs: Bellekte geçici alan; şifreli ara dosyalar gibi diske yazılmaması gereken veriler için.

Volume yedeği almak için:

# pgdata volume yedeği
docker run --rm   -v pgdata:/data   -v $(pwd)/backups:/backup   busybox tar czf /backup/pgdata-$(date +%Y%m%d).tar.gz /data

Bu komut geçici bir BusyBox container'ı başlatır, volume'u bağlar, sıkıştırır ve host'taki backups/ klasörüne yazar.

Network: Bridge, Host ve Container DNS

Compose, servislerin birbirine servis adıyla ulaşmasını sağlar; DATABASE_URL içinde db:5432 yazmak yeterlidir çünkü Compose her proje için ayrı bir bridge ağı oluşturur ve servis adlarını DNS olarak kaydeder.

Sürücü	Kullanım	Not
bridge	Varsayılan; tek host izolasyonu	Compose için standart
host	Container, host ağ stack'ini paylaşır	Yalnızca Linux; port eşleme gerekmez ama izolasyon yoktur
overlay	Docker Swarm / multi-host	Şifreli cross-host iletişim
macvlan	Container'a fiziksel MAC atar	İleri ağ senaryoları

Container'lar aynı Compose ağındaysa birbirlerine DNS adıyla ulaşabilir (http://app:3000). Farklı Compose projeleri arasında iletişim için dış ağ tanımlanır:

networks:
  shared:
    external: true

Reverse Proxy: Nginx, Traefik ve Caddy

Production'da container port'larını doğrudan dışarıya açmak yerine reverse proxy kullanın; TLS sonlandırma, log birleştirme ve yük dağılımı burada yapılır.

Nginx + Certbot: Klasik, olgun yaklaşım. nginx/default.conf:

server {
    listen 80;
    server_name siteniz.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name siteniz.com;
    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    location / {
        proxy_pass http://app:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

Let's Encrypt sertifikası için certbot certonly --standalone veya acme.sh ile sertifikayı alıp ssl/ dizinine yerleştirin.

Traefik: Label tabanlı, otomatik TLS yenileme. Her servise label ekleyerek Traefik'in otomatik konfigürasyon almasını sağlarsınız; yeni servis eklendiğinde Traefik'i yeniden başlatmaya gerek kalmaz. Production orta-büyük ölçekte tercih edilir.

Caddy: Yerleşik otomatik TLS içerir; Caddyfile konfigürasyonu minimal tutar. Küçük projeler için hızlı başlangıç sağlar.

Production Patterns: Env Vars, Log ve Restart

Ortam değişkenleri: Hassas bilgiler (DATABASE_PASSWORD, JWT_SECRET) .env dosyasında tutulur, docker compose --env-file .env up -d ile geçirilir. .env dosyasını asla image'a dahil etmeyin ve Git'e commit etmeyin. Compose Secrets, Docker Swarm veya Kubernetes Secret daha güvenli alternatiflerdir.

Logging driver: Varsayılan json-file driver log dosyaları oluşturur; döngüsel rotasyon için limitleyin:

services:
  app:
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

Merkezi log için Loki + Grafana veya syslog driver ile syslog sunucusu kullanılabilir.

Kaynak Limitleri: mem_limit, cpus ve OOMKilled

Container'ların host kaynaklarını tüketmesini engellemek için Compose içinde limit tanımlayın:

services:
  app:
    mem_limit: 512m
    memswap_limit: 512m   # swap kullanımını da kısıtla
    cpus: "1.0"
    pids_limit: 200

Container hafıza limitini aştığında kernel tarafından sonlandırılır (OOMKilled); docker inspect <container_id> çıktısında "OOMKilled": true görürsünüz. Bunu tespit etmek için:

docker inspect <container_id> | grep -i oom
# veya
docker events --filter event=oom

Docker Compose vs Kubernetes vs Docker Swarm

Senaryo	Öneri
Tek sunucu, küçük ekip, basit stack	Docker Compose
Çok sunucu, yüksek erişilebilirlik, küçük ekip	Docker Swarm
Mikro servis, büyük ekip, ileri orkestrasyon	Kubernetes

Docker Compose Buyukweb VDS gibi tek-sunucu senaryoları için doğrudan pratik çözümdür. Swarm, docker swarm init ve docker stack deploy ile Compose dosyasını multi-host'a taşır; ancak Kubernetes kadar zengin bir ekosisteme sahip değildir. Kubernetes'in öğrenme eğrisi yüksektir — küçük ekiplerin çoğu Compose'dan başlamak ve ihtiyaç doğduğunda Swarm veya K8s'e geçmek için güçlü gerekçe bulmak zorunda.

Buyukweb VDS Perspektifi

Buyukweb VDS sunucuları KVM + NVMe SSD + Bursa Tier 3 veri merkezi üzerinde çalışır. Docker, KVM içinde userspace container olarak sorunsuz kurulur; nested virtualization gerekmez. KVM web konsol, SSH erişiminin kesildiği acil durumlarda VNC arayüzünden müdahaleye imkân verir.

Minimum önerilen kapasite: 2 vCPU + 4 GB RAM (Node.js + Postgres + Nginx üçlüsü için). Daha yoğun workload'lar veya birden fazla Compose stack'i için 4 vCPU + 8 GB RAM daha rahat çalışır.

cPanel hosting farkı: cPanel paylaşımlı hosting paketlerinde root erişimi yoktur; Docker Engine kurulamaz. Eğer container ihtiyacınız varsa doğrudan VDS tercih edin.

cPanel sunucularda Docker: Buyukweb, yönetilen bir Docker hizmeti sunmamaktadır; VDS'te Docker kurulumu tamamen kullanıcı sorumluluğundadır. Bu dürüst bir kısıtlamadır.

Önerilen kurulum adımları (Ubuntu 24.04 VDS üzerinde):

# 1. Docker kur (yukarıdaki talimatlar)
# 2. Proje dizini oluştur
mkdir -p /var/www/uygulama && cd /var/www/uygulama

# 3. Repo çek, .env oluştur
git clone <repo-url> .
cp .env.example .env
nano .env   # DATABASE_URL, SECRET vb. düzenle

# 4. Stack başlat
docker compose up -d

# 5. Log kontrol
docker compose logs -f

Pratik Örnek: Node.js + Postgres + Nginx

Aşağıdaki docker-compose.yml üç servisli bir stack'i özetler:

services:
  app:
    build: .
    restart: unless-stopped
    environment:
      DATABASE_URL: postgresql://user:pass@db:5432/mydb
    depends_on:
      db:
        condition: service_healthy
    volumes:
      - uploads:/app/uploads
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
    mem_limit: 512m

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
      interval: 10s
      timeout: 5s
      retries: 5
    mem_limit: 1g

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - app
    mem_limit: 128m

volumes:
  pgdata:
  uploads:

Güvenlik: Image Tarama, Secret Yönetimi ve Rootless Docker

Image tarama: Resmi olmayan veya güncel olmayan image'lar bilinen CVE'ler içerebilir. docker scout cves <image> (Docker CLI entegrasyonu) veya açık kaynak Trivy ile image'ı tarayın:

# Trivy kurulumu (Ubuntu)
apt install -y wget apt-transport-https
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor -o /usr/share/keyrings/trivy.gpg
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | tee /etc/apt/sources.list.d/trivy.list
apt update && apt install -y trivy

# Tarama
trivy image node:20-alpine
trivy image myapp:latest

Docker Content Trust: Signed image doğrulaması için export DOCKER_CONTENT_TRUST=1 ortam değişkeni ayarlanır; bu sayede imzasız image pull edilemez.

Secret yönetimi: .env dosyası başlangıç için yeterli olsa da Docker Swarm Secrets veya HashiCorp Vault gibi çözümler, secret'ları şifreli depolar ve container'a bellek üzerinden erişim sağlar. Secret dosyaları disk üzerinde düz metin kalmaz.

Rootless Docker: Docker Engine'i root yerine normal kullanıcı olarak çalıştırmak mümkündür (dockerd-rootless-setuptool.sh install). Bu, container içindeki potansiyel sızma etkisini azaltır; Buyukweb VDS'te uygulanabilir ama ek konfigürasyon gerektiren ileri seviye bir pratiktir.

Sıkça Sorulan Sorular

Docker için hosting mi yoksa VDS mi tercih etmeliyim?

cPanel paylaşımlı hosting paketlerinde Docker kurulamaz çünkü root erişimi yoktur. Docker kullanmak için root erişimli bir VDS veya dedicated sunucu gerekir. Buyukweb VDS paketleri root erişim içerir ve Docker Engine kurulumunu tam destekler.

Docker Compose yeterli mi, Swarm veya Kubernetes gerekli mi?

Tek sunucuda çalışan küçük-orta ölçekli bir uygulama için Compose çoğunlukla yeterlidir. Birden fazla sunucuya yük dağıtmak istiyorsanız Swarm'a geçiş nispeten kolaydır (Compose dosyası büyük ölçüde uyumludur). Kubernetes, büyük ekipler ve ileri orkestrasyon senaryoları için uygundur; öğrenme eğrisi yüksektir.

Production'da Alpine tabanlı image güvenli midir?

Evet, güvenli ve yaygın kullanımdadır. Alpine'nin minimal paketi saldırı yüzeyini daraltır. Yalnızca glibc gerektiren bazı native Node.js modülleri (sharp gibi) Alpine üzerinde derleme sorunu yaşatabilir; bu durumda node:20-slim (Debian Slim) tercih edin.

Container içinde hot reload yapılabilir mi?

Geliştirme ortamında kaynak kodu bind mount olarak container'a bağlanır, uygulama nodemon veya --watch ile çalıştırılır:

services:
  app:
    build:
      context: .
      target: dev          # Multi-stage dev aşaması
    volumes:
      - .:/app             # Kaynak kodu bind mount
      - /app/node_modules  # node_modules yeniden yazılmasın
    command: npm run dev

Image boyutunu nasıl küçültürüm?

Multi-stage build en etkili yöntemdir. Ek olarak: npm ci --only=production ile sadece üretim bağımlılıklarını kurun, .dockerignore ile gereksiz dosyaları hariç tutun, mümkünse Alpine veya distroless base image kullanın. docker image history <image> komutuyla katman boyutlarını inceleyebilirsiniz.

Compose dosyasındaki depends_on service_healthy'i bekler mi?

depends_on varsayılan olarak yalnızca container'ın başladığını (started) bekler, hazır olduğunu değil. Gerçek hazırlık denetimi için condition: service_healthy ve ilgili servise healthcheck tanımlanması gerekir (yukarıdaki Compose örneklerinde bu gösterilmiştir).

Volume verilerini yedeklemenin en kolay yolu nedir?

docker run --rm -v <volume_name>:/data -v $(pwd)/backups:/backup busybox tar czf /backup/<dosya>.tar.gz /data komutu ile named volume'ların anlık yedeği alınır. Bu komut bir cron job ile günlük olarak otomatik hale getirilebilir.

Sonuç

Docker, uygulamayı ortamından bağımsız kılar; Dockerfile ile image tanımlanır, Compose ile servisler birleştirilir, reverse proxy ile production trafiği yönetilir. Buyukweb VDS üzerinde kurulum için resmi docker-ce deposundan paket kurun, minimum 2 vCPU + 4 GB RAM ile Node.js + Postgres + Nginx stack'ini Compose ile ayağa kaldırın. Başlangıç için restart: unless-stopped, named volume ve healthcheck üçlüsünü uygulayın; güvenlik için non-root kullanıcı ve Trivy taramasını ekleyin.

Teknik destek için: 0850 302 60 70 veya iletişim sayfamız.

---

İlgili Büyükweb Hizmetleri

Docker stack'inizi Türkiye lokasyonlu sunucularda çalıştırmak için:

• VDS Sunucu — root yetkili, Docker Engine + Compose kurulumu serbest
• E5 v4 VDS — NVMe SSD, yoğun Postgres/Redis workload için yüksek IOPS
• Fiziksel Dedicated Sunucu — Yüksek ölçek, tam kontrol
• Nested VDS — Sanallaştırma katmanı üzerinde ek esneklik
• GPU Sunucu — GPU gerektiren container iş yükleri

Sorularınız için 0850 302 60 70 numaralı destek hattımıza veya iletişim sayfamıza yazabilirsiniz.