# Jupyter Notebook'ta GPU Kullanımı: Bulut Sunucuda Güvenli JupyterLab Rehberi

- Adres: https://gpukiralama.com.tr/blog/jupyter-bulut-gpu-rehberi/
- Kategori: Teknik
- Yayın: 2026-10-24 · Son güncelleme: 2026-10-28

Jupyter Notebook'ta GPU kullanmak için notebook'u CUDA destekli PyTorch ortamının çekirdeğiyle açın ve torch.cuda.is_available() ile kontrol edin. Uzak sunucuda JupyterLab'i yalnızca 127.0.0.1 adresinde çalıştırıp SSH tüneliyle bağlanın. Docker, VS Code, tmux, systemd ve GPU belleği yönetimi adım adım.

## Kısa cevap

Jupyter Notebook'ta GPU'yu Jupyter'in kendisi değil, çekirdekteki kütüphane (PyTorch, TensorFlow) kullanır: notebook'u CUDA destekli PyTorch kurulu bir ortamın çekirdeğiyle açın, `torch.cuda.is_available()` `True` dönüyorsa model ve veriyi `.to("cuda")` ile GPU'ya taşıyın. Uzak GPU sunucusunda JupyterLab'i internete açmayın: sunucuda yalnızca `127.0.0.1` adresini dinletin ve kendi bilgisayarınızdan SSH tüneliyle bağlanın.

Ekim 2026 itibarıyla güncel JupyterLab sürümü 4.6'dır ve Python 3.10 veya üzerini ister.

- JupyterLab'i ayrı bir sanal ortama kurun; her projeyi `ipykernel` ile ayrı bir çekirdek (kernel) olarak ekleyin.
- Jupyter'i `tmux` içinde ya da systemd kullanıcı servisi olarak çalıştırın ki SSH bağlantısı kopunca kapanmasın.
- GPU belleğini `nvidia-smi` veya `nvtop` ile izleyin; saatler süren eğitimleri notebook'tan betiğe taşıyın.

## Jupyter Notebook'ta GPU nasıl kullanılır ve kontrol edilir?

Jupyter'de açılması gereken ayrı bir GPU ayarı yoktur; Colab'daki çalışma zamanı türü seçiminin karşılığı, notebook'u doğru çekirdekle açmaktır. Çekirdeğin ortamında CUDA destekli PyTorch kuruluysa ve sunucuda NVIDIA sürücüsü çalışıyorsa GPU kullanıma hazırdır. İlk hücrede şunu çalıştırın:

```python
import torch

print(torch.cuda.is_available())      # True olmalı
print(torch.cuda.device_count())      # görünen GPU sayısı
print(torch.cuda.get_device_name(0))  # kartın adı
print(torch.version.cuda)             # None ise CPU sürümü kurulu
```

Sürücünün kartı gördüğünü notebook'tan da doğrulayabilirsiniz: bir hücreye `!nvidia-smi` yazın. Ardından modeli ve veriyi GPU'ya taşıyın; ikisi aynı cihazda değilse PyTorch hata verir:

```python
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
inputs = inputs.to(device)
```

- **Terminalde GPU görünüyor ama notebook'ta `False` dönüyorsa** notebook büyük olasılıkla PyTorch'un CPU sürümünün kurulu olduğu ya da PyTorch'un hiç bulunmadığı bir ortamda çalışıyordur. Bir hücrede `import sys; print(sys.executable)` çalıştırın ve aşağıda anlatıldığı gibi proje ortamını çekirdek olarak ekleyin.
- **Belirli bir GPU'yu kullanmak için** (sunucuda birden fazla kart varsa) `import torch` satırından önce bir hücrede `%env CUDA_VISIBLE_DEVICES=1` çalıştırın. CUDA başlatıldıktan sonra yapılan değişiklik etkisizdir; o durumda çekirdeği yeniden başlatın.
- **TensorFlow kullanıyorsanız** kontrol komutu `tf.config.list_physical_devices("GPU")` olur.

Eğitim sırasında `nvidia-smi` çıktısında GPU kullanım yüzdesi ve bellek yükseliyorsa iş gerçekten GPU'da çalışıyordur.

## Jupyter'e uzaktan bağlanmanın hangi yolu güvenli?

En güvenli iki yol SSH tüneli ve VS Code Remote-SSH'tır; ikisinde de Jupyter'in portu dışarıya kapalı kalır.

| Yöntem | Güvenlik | Ne zaman |
|---|---|---|
| SSH tüneli + JupyterLab (`127.0.0.1`) | Port internete kapalı, trafik SSH ile şifreli | Tarayıcıda JupyterLab kullanacaksanız varsayılan yol |
| VS Code Remote-SSH | Yalnızca SSH bağlantısı kullanılır | Kodu ve notebook'u aynı editörde yazıyorsanız |
| Portu internete açmak (`--ip 0.0.0.0`) | Zayıf: Jupyter'e erişen, sunucuda kod çalıştırabilir | Önerilmez |

Jupyter Server belgeleri de bunu vurgular: sunucuya erişim, keyfi kod çalıştırma yetkisi demektir; bu yüzden erişim mutlaka kısıtlanmalıdır. Sunucunun geri kalanı için (parola yerine SSH anahtarı, güvenlik duvarı kuralları) [kiralık GPU sunucusunda güvenlik kontrol listesine](/blog/kurumsal-gpu-kiralama-guvenlik-sla/) bakın.

## JupyterLab sunucuya nasıl kurulur?

JupyterLab'i sistem Python'una değil, kendi sanal ortamına kurun:

```bash
sudo apt install -y python3-venv
python3 -m venv ~/jupyter-env
source ~/jupyter-env/bin/activate
pip install --upgrade pip
pip install jupyterlab
```

Bu ortamda yalnızca Jupyter bulunur; PyTorch ve proje paketleri aşağıda anlatılan proje ortamlarına kurulur. Böylece bir projedeki paket güncellemesi Jupyter'i ya da başka bir projeyi bozmaz. NVIDIA'nın NGC PyTorch konteynerini kullanıyorsanız JupyterLab imajın içinde hazır gelir.

## Jupyter internete açılmadan nasıl bağlanırsınız?

Sunucuda Jupyter'i yerel adrese bağlayın, kendi bilgisayarınızda bir SSH tüneli açın:

```bash
# Sunucuda
jupyter lab --no-browser --ip 127.0.0.1 --port 8888

# Kendi bilgisayarınızda (-N: uzak komut çalıştırmadan yalnızca tünel açar)
ssh -N -L 8888:127.0.0.1:8888 kullanici@sunucu-ip
```

Ardından sunucunun ekrana yazdığı, `token=` içeren adresi kendi tarayıcınızda açın. Her seferinde aynı komutu yazmamak için tüneli `~/.ssh/config` dosyanıza ekleyebilirsiniz:

```text
Host gpu
    HostName sunucu-ip
    User kullanici
    LocalForward 8888 127.0.0.1:8888
    ServerAliveInterval 60
```

Bundan sonra `ssh -N gpu` yeterlidir. `ServerAliveInterval 60`, sunucudan 60 saniye boyunca veri gelmezse SSH'ın şifreli kanal üzerinden bir yoklama mesajı göndermesini sağlar. İki pratik not:

- 8888 portu doluysa Jupyter sıradaki portları dener (varsayılan olarak 50 porta kadar); sunucu çıktısındaki port numarasını tünelde de kullanın.
- Jupyter'i Docker içinde çalıştırıyorsanız portu `-p 127.0.0.1:8888:8888` biçiminde yayımlayın. Docker belgelerine göre yalnızca `-p 8888:8888` yazmak portu tüm ağ arayüzlerinde açar; UFW ile engellemiş olsanız bile port dışarıdan erişilebilir olur.

## Jupyter'i Docker'da GPU ile nasıl çalıştırırsınız?

Konteynere GPU vermek için önce [NVIDIA Container Toolkit kurulumu](/blog/docker-nvidia-container-toolkit-kurulum/) gerekir. Ardından en kısa yol, JupyterLab'in hazır geldiği NVIDIA NGC PyTorch imajıdır:

```bash
docker run --gpus all --ipc=host -it --rm \
  -p 127.0.0.1:8888:8888 \
  -v ~/projeler:/workspace/projeler \
  nvcr.io/nvidia/pytorch:26.09-py3 \
  jupyter lab --ip 0.0.0.0 --port 8888 --no-browser --allow-root
```

- Konteynerin içinde Jupyter `0.0.0.0` adresini dinlemelidir; `127.0.0.1` yazarsanız yayımlanan port konteynere ulaşmaz. Portu dışarıya kapalı tutan, sunucu tarafındaki `-p 127.0.0.1:8888:8888` ifadesidir; bağlanmak için yukarıdaki SSH tünelini aynen kullanın.
- NGC imajları varsayılan olarak root kullanıcısıyla çalıştığı için `--allow-root` gerekir.
- `--rm` ile başlatılan konteyner kapanınca silinir; notebook'larınızı `-v` ile bağladığınız klasörde tutun.
- `--ipc=host`, PyTorch DataLoader'ın çok işçili veri yüklemesi için gereken paylaşımlı belleği sağlar; yerine `--shm-size` da kullanılabilir.

Compose dosyasında GPU tanımlamak ve belirli bir kartı seçmek için [Docker'da GPU kullanımı rehberimize](/blog/docker-gpu-kullanim-rehberi/) bakın.

## Token mı, parola mı kullanmalı?

Varsayılan token yeterlidir; sık bağlanıyorsanız parola daha pratiktir. Jupyter Server token doğrulamasını varsayılan olarak açar ve token'ı başlangıçta ekrana yazar. Çalışan sunucuların token'lı adreslerini sonradan görmek için `jupyter server list` komutunu kullanın.

Kalıcı bir parola belirlemek için `jupyter server password` komutunu çalıştırın. Parolanın özeti (hash) `jupyter_server_config.json` dosyasına yazılır; parola tanımlıyken token kendiliğinden devreye girmez. Token'ı ve parolayı boş bırakarak doğrulamayı tamamen kapatmak mümkündür ama belgelerde açıkça önerilmez; tünel kullansanız bile kapatmayın.

## VS Code ile notebook çalıştırmak bir alternatif mi?

Evet; VS Code'un Remote-SSH eklentisiyle sunucuya bağlanırsanız ayrı bir tünele gerek kalmaz.

1. Kendi bilgisayarınızdaki VS Code'a Remote-SSH eklentisini kurun.
2. Komut paletinden "Remote-SSH: Connect to Host..." komutuyla sunucuya bağlanın.
3. Python ve Jupyter eklentilerini sunucu tarafına kurun; eklentilerin çoğu uzak makinede çalışır.
4. Bir `.ipynb` dosyası açın ve sağ üstteki çekirdek seçiciden proje ortamınızı seçin.

VS Code belgelerine göre notebook çalıştıracağınız Python ortamında Jupyter paketi kurulu olmalıdır.

## Her proje için ayrı çekirdek (kernel) nasıl tanımlanır?

Her projenin sanal ortamına `ipykernel` kurup ortamı Jupyter'e bir çekirdek olarak tanıtın:

```bash
python3 -m venv ~/envs/proje-a
source ~/envs/proje-a/bin/activate
pip install torch torchvision ipykernel
python -m ipykernel install --user --name proje-a --display-name "Python (proje-a)"
```

JupyterLab'de yeni bir notebook açarken "Python (proje-a)" listede görünür. `--name` Jupyter'in iç adıdır, `--display-name` menüde gördüğünüz addır; aynı adla yapılan yeni kurulum eskisinin üzerine yazılır. Kayıtlı çekirdekleri `jupyter kernelspec list` ile görebilir, gereksiz olanı `jupyter kernelspec uninstall proje-a` ile kaldırabilirsiniz. Notebook'un hangi ortamda çalıştığından emin olmak için bir hücrede `import sys; print(sys.executable)` çalıştırın. PyTorch kurulumu ve sürücü gereksinimi için [PyTorch GPU kurulum rehberimize](/blog/pytorch-gpu-kurulum-rehberi/) bakın.

## SSH kopunca Jupyter'in kapanmaması için ne yapmalı?

Jupyter'i doğrudan SSH oturumunda başlatırsanız bağlantı kopunca o da kapanır. Bunu önlemenin iki yolu var:

| Yöntem | Avantajı | Dezavantajı |
|---|---|---|
| tmux | Ek yapılandırma gerektirmez, çıktıyı canlı görürsünüz | Sunucu yeniden başlarsa Jupyter'i elle açmanız gerekir |
| systemd kullanıcı servisi | Açılışta kendiliğinden başlar, hata verip kapanırsa yeniden başlatılır | Bir kez servis dosyası yazmanız gerekir |

tmux ile:

```bash
tmux new -s jupyter
source ~/jupyter-env/bin/activate
jupyter lab --no-browser --ip 127.0.0.1 --port 8888
# Ctrl-b, ardından d: oturumdan ayrılın; Jupyter çalışmaya devam eder
tmux attach -t jupyter    # daha sonra geri dönmek için
```

systemd ile önce `~/.config/systemd/user/jupyter.service` dosyasını oluşturun:

```ini
[Unit]
Description=JupyterLab

[Service]
WorkingDirectory=%h/projeler
ExecStart=%h/jupyter-env/bin/jupyter lab --no-browser --ip 127.0.0.1 --port 8888
Restart=on-failure

[Install]
WantedBy=default.target
```

Sonra servisi etkinleştirin:

```bash
mkdir -p ~/projeler
systemctl --user daemon-reload
systemctl --user enable --now jupyter.service
sudo loginctl enable-linger $USER
```

`%h` ev dizininizi ifade eder. `loginctl enable-linger`, kullanıcı servislerinizin sunucu açılışında başlamasını ve oturumunuz kapandıktan sonra da çalışmasını sağlar. Token'lı adresi görmek için `~/jupyter-env/bin/jupyter server list` komutunu çalıştırın ya da bir parola tanımlayın.

## Notebook'tan GPU nasıl izlenir?

Sunucu tarafında `nvidia-smi` ya da daha görsel `nvtop`, notebook içinde ise PyTorch'un bellek sayaçları yeterlidir:

```bash
nvidia-smi -l 2            # 2 saniyede bir yeniler
sudo apt install -y nvtop  # Ubuntu 20.04 ve sonrasında depoda
nvtop
```

```python
import torch

gb = 1024**3
print(f"Tensörlerin kullandığı: {torch.cuda.memory_allocated() / gb:.1f} GB")
print(f"PyTorch'un ayırdığı:    {torch.cuda.memory_reserved() / gb:.1f} GB")
print(f"Oturumdaki zirve:       {torch.cuda.max_memory_allocated() / gb:.1f} GB")
```

PyTorch, serbest bıraktığı belleği bir önbellekte tutar ve bu bellek `nvidia-smi`'de hala kullanılıyor görünür. Bu yüzden `nvidia-smi`'deki değer, tensörlerin gerçekten kullandığı bellekten yüksek olabilir.

GPU kullanımını JupyterLab'in içinde grafik olarak izlemek isterseniz RAPIDS ekibinin geliştirdiği `jupyterlab-nvdashboard` eklentisini Jupyter'in kendi ortamına kurup JupyterLab'i yeniden başlatın. Eklenti GPU kullanımını, GPU belleğini, PCIe ve NVLink trafiğini canlı grafiklerle gösterir; JupyterLab 4 ve Python 3.11 veya üzerini ister.

```bash
source ~/jupyter-env/bin/activate
pip install jupyterlab-nvdashboard
```

## Notebook'ta GPU belleği neden boşalmıyor?

Çünkü bir şey hala tensörlere referans tutuyordur: değişkenleriniz, IPython'un çıktı önbelleği ya da PyTorch'un bellek önbelleği. Sırasıyla şunları deneyin:

1. Büyük nesneleri silin ve çöp toplayıcıyı çalıştırın.
2. Önbellekteki boş belleği `torch.cuda.empty_cache()` ile geri verin.
3. Bellek hala doluysa çekirdeği yeniden başlatın; en kesin yol budur.

```python
import gc
import torch

del model, optimizer, outputs
gc.collect()
torch.cuda.empty_cache()
```

Bilmeniz gereken üç ayrıntı:

- `empty_cache()` yalnızca kullanılmayan önbelleği başka uygulamalara (ör. ikinci bir notebook'a) geri verir; canlı tensörlerin belleğini boşaltmaz ve PyTorch'un kullanabileceği belleği artırmaz.
- IPython, hücrelerin döndürdüğü sonuçları `_`, `_12` ve `Out[12]` gibi değişkenlerde saklar; bu da çöp toplayıcının onları silmesini engeller. Büyük bir tensörü hücrenin son satırında döndürmeyin; gerekirse `%xdel` ya da `%reset` komutlarıyla temizleyin.
- Açık her notebook ayrı bir çekirdek sürecidir ve kendi GPU belleğini tutar; kullanmadığınız notebook'ların çekirdeğini kapatın.

## Uzun eğitimleri notebook'tan betiğe nasıl taşırsınız?

Notebook keşif ve hata ayıklama için idealdir; [saatler süren bir eğitimi](/hizmetler/ai-egitimi/) ise betiğe çevirip tmux içinde, çıktısını bir dosyaya yazarak çalıştırmak daha güvenlidir. Hücrelerin farklı sırayla çalıştırılması gizli bir durum (state) yaratır; betik her seferinde baştan sona aynı şekilde çalışır.

```bash
jupyter nbconvert --to script deney.ipynb   # deney.py dosyasını oluşturur
tmux new -s egitim
source ~/envs/proje-a/bin/activate
python deney.py 2>&1 | tee egitim.log
```

Dönüştürülen dosyada `%` ya da `!` ile başlayan notebook komutları kaldıysa onları temizleyin. Betikte belirli aralıklarla checkpoint kaydedin ki süreç yarıda kesilse bile kaldığınız yerden devam edebilesiniz. Eğitimi hızlandırmak için [CUDA optimizasyonu rehberimize](/blog/cuda-optimizasyonu-rehberi/) bakabilirsiniz.

## Bu iş için hangi GPU?

Notebook'la keşif, veri hazırlama ve küçük modeller için [RTX PRO 4000](/gpu-modelleri/nvidia-rtx-pro-4000/) (24 GB, aylık $450) yeterlidir. 7–14B parametreli dil modelleriyle notebook'ta deney yapacaksanız [L40S](/gpu-modelleri/nvidia-l40s/) (48 GB, aylık $900) daha rahat bir başlangıçtır. Modelinizin hangi karta sığacağını [VRAM hesaplayıcımızla](/araclar/vram-hesaplayici/) önceden görebilirsiniz. Sunucularımız Bağcılar, İstanbul'daki kendi tesisimizdedir; [verileriniz Türkiye'de kalır](/blog/kvkk-gpu-kiralama-turkiye/), GPU'lar ve sunucu kaynakları başka müşterilerle paylaşılmaz. RAPIDS ile pandas ve scikit-learn kodunu GPU'da çalıştırmayı ve veri boyutuna göre kart seçimini [veri bilimi hizmet sayfamızda](/hizmetler/veri-bilimi/) anlattık.

Kiralama aylıktır ve en az bir aydır. Fiyatlar GPU başına, ABD doları cinsinden ve KDV hariçtir; fatura tarihindeki TCMB satış kuruyla Türk lirası olarak faturalanır. Sunucuyu 7/24 açık tutarsanız RTX PRO 4000'in saatlik karşılığı $0,62 olur; yıllık kiralamada %20 indirim uygulanır. Haftada yalnızca birkaç saat notebook çalıştırıyorsanız Colab ya da saatlik bir bulut daha ekonomik olabilir; farkları [Colab ile GPU kiralama karşılaştırmamızda](/blog/google-colab-vs-gpu-kiralama/) anlattık.

## Özet

- Notebook'ta GPU'yu `torch.cuda.is_available()` ve `!nvidia-smi` ile kontrol edin; model ve veriyi `.to("cuda")` ile GPU'ya taşıyın.
- Jupyter'i internete açmayın: sunucuda `--ip 127.0.0.1`, kendi bilgisayarınızda `ssh -N -L 8888:127.0.0.1:8888`; Docker'da portu `-p 127.0.0.1:8888:8888` ile yayımlayın, konteyner içinde Jupyter `0.0.0.0` adresini dinlesin.
- Token doğrulaması varsayılan olarak açıktır; `jupyter server password` ile kalıcı parola tanımlayabilirsiniz, doğrulamayı ise asla kapatmayın.
- JupyterLab'i ayrı bir ortama kurun, her projeyi `python -m ipykernel install --user --name ...` ile çekirdek olarak ekleyin.
- SSH kopmalarına karşı tmux ya da `loginctl enable-linger` ile birlikte bir systemd kullanıcı servisi kullanın.
- `empty_cache()` canlı tensörleri silmez; bellek boşalmıyorsa referansları silin ya da çekirdeği yeniden başlatın. Uzun eğitimleri betiğe taşıyın.

## Kaynaklar

- [Jupyter Server: Security in the Jupyter Server](https://jupyter-server.readthedocs.io/en/latest/operators/security.html)
- [JupyterLab: Installation](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html)
- [IPython: Installing the IPython kernel](https://ipython.readthedocs.io/en/stable/install/kernel_install.html)
- [OpenBSD: ssh(1) kılavuz sayfası](https://man.openbsd.org/ssh)
- [VS Code: Remote Development using SSH](https://code.visualstudio.com/docs/remote/ssh)
- [systemd: loginctl](https://www.freedesktop.org/software/systemd/man/latest/loginctl.html)
- [PyTorch: CUDA semantics, memory management](https://docs.pytorch.org/docs/stable/notes/cuda.html)
- [Docker: docker container run](https://docs.docker.com/reference/cli/docker/container/run/)
- [NVIDIA NGC: PyTorch container](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch)
- [NVIDIA Container Toolkit: Installing the NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
- [PyTorch: torch.cuda](https://docs.pytorch.org/docs/stable/cuda.html)
- [TensorFlow: Use a GPU](https://www.tensorflow.org/guide/gpu)
- [NVIDIA: CUDA ortam değişkenleri (CUDA_VISIBLE_DEVICES)](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#env-vars)
- [RAPIDS: jupyterlab-nvdashboard](https://github.com/rapidsai/jupyterlab-nvdashboard)

## Sık sorulan sorular

**Tarayıcı sekmesini kapatırsam çalışan hücre durur mu?**
Hayır. Çekirdek sunucuda çalışır ve tarayıcıyı kapatmanız onu durdurmaz. Ancak Jupyter sunucusunu doğrudan SSH oturumunda başlattıysanız bağlantı kopunca çekirdekler de kapanır; bu yüzden tmux ya da systemd kullanın.

**Birden fazla kişi aynı sunucuda Jupyter kullanabilir mi?**
Evet; her kullanıcı kendi hesabında, farklı bir portta kendi Jupyter'ini çalıştırıp kendi SSH tünelini kullanabilir. Aynı GPU'yu paylaşan kullanıcıların belleği birbirinden yalıtılmaz; yalıtım için ayrı GPU'lar ya da MIG destekleyen kartlar gerekir.

**Modelim küçük ama nvidia-smi neden çok bellek kullanıldığını gösteriyor?**
PyTorch, serbest bıraktığı belleği yeniden kullanmak için önbellekte tutar ve nvidia-smi bu belleği kullanılıyor gösterir. Tensörlerin gerçek kullanımını torch.cuda.memory_allocated() ile görebilir, boş önbelleği torch.cuda.empty_cache() ile başka uygulamalara geri verebilirsiniz.

**JupyterLab mi, VS Code mu kullanmalıyım?**
İkisi de sunucudaki aynı Python ortamlarını kullanabilir. Tarayıcıda çalışan, kurulumu sade bir ortam istiyorsanız JupyterLab; kodu, Git'i ve notebook'ları tek editörde toplamak istiyorsanız VS Code Remote-SSH daha pratiktir.

**Jupyter'de "CUDA out of memory" hatası alırsam ne yapmalıyım?**
Önce aynı GPU'yu kullanan diğer notebook çekirdeklerini kapatın ve büyük değişkenleri silin; bellek yine yetmiyorsa batch boyutunu küçültün, bf16 karışık hassasiyet kullanın ya da gradient checkpointing'i açın. Hatadan sonra bellek dolu kalırsa çekirdeği yeniden başlatmak en kesin çözümdür.

**Jupyter için GPU sunucusu kiralamak aylık ne kadar?**
Notebook'la keşif ve küçük modeller için 24 GB'lık RTX PRO 4000 aylık $450, 7–14B parametreli dil modelleri için 48 GB'lık L40S aylık $900 ile kiralanır; fiyatlar GPU başına, ABD doları cinsinden ve KDV hariçtir. Sunucu paylaşımsızdır, Bağcılar, İstanbul'daki tesisimizde çalışır ve yıllık kiralamada %20 indirim uygulanır.