Ray Clusters untuk AI: Arsitektur Komputasi Terdistribusi

Diperbarui 11 Desember 2025

Pembaruan Desember 2025: OpenAI menggunakan Ray untuk mengoordinasikan pelatihan ChatGPT. Ray bergabung dengan PyTorch Foundation memvalidasi adopsi enterprise. Framework berskala dari laptop hingga ribuan GPU. Mencapai jutaan tugas per detik dengan latensi sub-milidetik—satu orde magnitudo lebih cepat dari Spark untuk pola AI. Dukungan native untuk komputasi heterogen yang memungkinkan pencampuran workload CPU/GPU.

OpenAI menggunakan Ray untuk mengoordinasikan pelatihan ChatGPT dan model-model lainnya.¹ Framework ini berskala dari laptop hingga cluster dengan ribuan GPU, menangani kompleksitas komputasi terdistribusi yang seharusnya membutuhkan infrastruktur kustom untuk setiap proyek. Adopsi Ray melonjak sepanjang tahun 2025, divalidasi oleh bergabungnya framework ini ke PyTorch Foundation dan Anyscale yang mengumpulkan modal untuk mendukung deployment enterprise.² Memahami arsitektur dan pola deployment Ray membantu organisasi membangun infrastruktur AI terdistribusi yang berskala dari eksperimentasi hingga produksi.

Ray menyediakan framework terpadu untuk workload AI terdistribusi—pelatihan, tuning, inferensi, dan pemrosesan data—yang mengabstraksi kompleksitas manajemen cluster sambil mempertahankan kontrol granular atas alokasi sumber daya. Untuk organisasi yang bergerak melampaui eksperimentasi single-GPU ke sistem produksi multi-node, Ray menawarkan jalur paling langsung menuju infrastruktur AI yang skalabel.

Mengapa Ray untuk infrastruktur AI

Ray muncul dari RISELab UC Berkeley untuk mengatasi tantangan spesifik workload AI terdistribusi yang ditangani dengan buruk oleh framework tradisional seperti Apache Spark:

Persyaratan workload AI

Komputasi heterogen: Pipeline AI mencampurkan pemrosesan data intensif-CPU dengan pelatihan dan inferensi yang dipercepat GPU. Ray secara native mendukung alokasi sumber daya heterogen, menjadwalkan tugas di seluruh CPU dan GPU sesuai permintaan workload.³

Paralelisme granular: Pelatihan deep learning membutuhkan koordinasi gradien di seluruh worker, mengelola state model, dan menangani kegagalan dengan baik. Abstraksi task dan actor Ray menyediakan primitif yang diperlukan untuk pola-pola ini.

Komputasi stateful: Tidak seperti framework gaya MapReduce, workload AI sering mempertahankan state di seluruh iterasi. Actor Ray mempertahankan state antar pemanggilan, mendukung pola seperti parameter server dan agent reinforcement learning.

Latensi rendah: Inferensi real-time dan pencarian hyperparameter membutuhkan penjadwalan tugas dalam mikrodetik. Ray mencapai jutaan tugas per detik dengan latensi sub-milidetik—satu orde magnitudo lebih cepat dari Spark untuk pola-pola ini.⁴

Perbandingan dengan alternatif

Apache Spark: Dioptimalkan untuk pemrosesan data batch dengan SQL dan DataFrame. Unggul dalam ETL, feature engineering, dan analitik pada data terstruktur. Kurang cocok untuk workload GPU, komputasi stateful, dan persyaratan latensi rendah.⁵

Dask: Komputasi terdistribusi native Python dengan API DataFrame dan array. Lebih ringan dari Spark tetapi tidak memiliki model actor Ray dan library khusus ML.

Horovod: Fokus khusus pada pelatihan deep learning terdistribusi. Kurang fleksibel dibanding Ray untuk workload AI yang beragam tetapi lebih sederhana untuk skenario pelatihan murni.

Keunggulan Ray: Satu framework menangani pemrosesan data, pelatihan, tuning hyperparameter, dan penyajian inferensi. Tim menghindari pengelolaan beberapa sistem dan kompleksitas integrasi di antaranya.

Adopsi produksi

Organisasi besar menjalankan Ray di produksi:⁶

• OpenAI: Koordinasi pelatihan ChatGPT
• Uber: Platform ML terdistribusi
• Instacart: Tulang punggung infrastruktur ML
• Shopify: Workload ML produksi
• Ant Group: ML finansial skala besar

Ray cluster secara resmi mendukung hingga 2.000 node, memungkinkan skala yang dibutuhkan untuk pelatihan model frontier dan inferensi volume tinggi.

Arsitektur Ray

Abstraksi inti

Ray menyediakan dua abstraksi fundamental untuk komputasi terdistribusi:

Tasks: Fungsi stateless yang dieksekusi secara remote. Ray secara otomatis menjadwalkan task di seluruh worker yang tersedia, menangani kegagalan, dan mengembalikan hasil.

import ray

ray.init()

@ray.remote
def process_batch(data):
    # Berjalan di worker mana pun yang tersedia
    return transform(data)

# Eksekusi secara paralel
futures = [process_batch.remote(batch) for batch in batches]
results = ray.get(futures)

Actors: Objek stateful yang didistribusikan di seluruh cluster. Setiap actor mempertahankan state antar pemanggilan method, memungkinkan pola seperti penyajian model, parameter server, dan environment game.

@ray.remote
class ModelServer:
    def __init__(self, model_path):
        self.model = load_model(model_path)

    def predict(self, input_data):
        return self.model(input_data)

# Buat instance actor
server = ModelServer.remote("model.pt")
# Panggil method secara remote
prediction = ray.get(server.predict.remote(data))

Arsitektur cluster

Ray cluster terdiri dari head node dan worker node:

Head node: Menjalankan Global Control Store (GCS) yang mengelola state cluster, object directory yang melacak lokasi data, dan scheduler yang mengoordinasikan penempatan task.

Worker node: Mengeksekusi task dan actor. Setiap worker menjalankan daemon Raylet yang menangani penjadwalan lokal dan manajemen objek.

Object store: Shared memory terdistribusi yang memungkinkan zero-copy data passing antar task di node yang sama dan serialisasi efisien antar node.

Manajemen sumber daya

Ray mengelola sumber daya heterogen secara eksplisit:

@ray.remote(num_cpus=4, num_gpus=1)
def train_step(model, data):
    # Dijamin 4 CPU dan 1 GPU
    return model.train(data)

Custom resource memungkinkan penjadwalan granular:

# Meminta hardware spesifik
@ray.remote(resources={"TPU": 1})
def tpu_inference(data):
    return run_on_tpu(data)

Library AI Ray

Ray menyertakan library yang dibangun khusus untuk workload AI umum:

Ray Train

Abstraksi pelatihan terdistribusi yang mendukung PyTorch, TensorFlow, dan framework lainnya:

from ray.train.torch import TorchTrainer
from ray.train import ScalingConfig

def train_func():
    # Kode pelatihan PyTorch standar
    model = MyModel()
    for epoch in range(10):
        train_epoch(model)

trainer = TorchTrainer(
    train_loop_per_worker=train_func,
    scaling_config=ScalingConfig(
        num_workers=8,
        use_gpu=True
    ),
)
result = trainer.fit()

Kapabilitas utama:⁷ - Skala dari single GPU ke cluster multi-node dengan perubahan 2 baris kode - Data loading terdistribusi otomatis dan sinkronisasi gradien - Manajemen checkpoint dan pemulihan dari kegagalan - Integrasi dengan PyTorch Lightning, Hugging Face Transformers, dan DeepSpeed

Ray Tune

Optimasi hyperparameter terdistribusi:

from ray import tune
from ray.tune.schedulers import ASHAScheduler

def training_function(config):
    model = build_model(config["learning_rate"], config["batch_size"])
    for epoch in range(100):
        loss = train_epoch(model)
        tune.report(loss=loss)

analysis = tune.run(
    training_function,
    config={
        "learning_rate": tune.loguniform(1e-4, 1e-1),
        "batch_size": tune.choice([32, 64, 128])
    },
    scheduler=ASHAScheduler(metric="loss", mode="min"),
    num_samples=100,
)

Ray Tune menyediakan: - Eksekusi trial paralel di seluruh cluster - Early stopping dengan ASHA, Population-Based Training, dan scheduler lainnya - Integrasi dengan Optuna, HyperOpt, dan library optimasi lainnya - Checkpointing dan resumption

Ray Serve

Penyajian model produksi dengan autoscaling:

from ray import serve

@serve.deployment(num_replicas=2, ray_actor_options={"num_gpus": 1})
class LLMDeployment:
    def __init__(self):
        self.model = load_llm()

    async def __call__(self, request):
        prompt = await request.json()
        return self.model.generate(prompt["text"])

serve.run(LLMDeployment.bind())

Kapabilitas Ray Serve:⁸ - Autoscaling berdasarkan request rate - Deployment tanpa downtime - Komposisi multi-model dan routing request - API kompatibel OpenAI untuk penyajian LLM - Pengurangan 60% pada time-to-first-token dengan prefix-aware routing⁹

Ray Data

Data loading dan preprocessing terdistribusi:

import ray

ds = ray.data.read_parquet("s3://bucket/data/")
ds = ds.map(preprocess)
ds = ds.filter(lambda x: x["label"] > 0)

# Konversi ke PyTorch DataLoader
train_loader = ds.iter_torch_batches(batch_size=32)

Ray Data menyediakan: - Eksekusi streaming untuk dataset besar - Preprocessing yang dipercepat GPU - Integrasi dengan Ray Train untuk pelatihan terdistribusi - Dukungan native untuk data gambar, teks, dan tabular

Deployment Kubernetes dengan KubeRay

Deployment Ray produksi biasanya berjalan di Kubernetes menggunakan KubeRay, operator Kubernetes resmi:¹⁰

Komponen KubeRay

RayCluster CRD: Mendefinisikan konfigurasi cluster termasuk spesifikasi head dan worker node, kebijakan autoscaling, dan persyaratan sumber daya.

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ml-cluster
spec:
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
    template:
      spec:
        containers:
        - name: ray-head
          image: rayproject/ray:2.52.0-py310-gpu
          resources:
            limits:
              nvidia.com/gpu: 1
  workerGroupSpecs:
  - replicas: 4
    minReplicas: 2
    maxReplicas: 10
    groupName: gpu-workers
    rayStartParams: {}
    template:
      spec:
        containers:
        - name: ray-worker
          image: rayproject/ray:2.52.0-py310-gpu
          resources:
            limits:
              nvidia.com/gpu: 1

RayJob CRD: Mengirim job ke cluster yang disediakan secara otomatis. KubeRay membuat cluster, menjalankan job, dan secara opsional menghapus cluster saat selesai.

RayService CRD: Deployment Ray Serve yang dikelola dengan upgrade tanpa downtime dan health checking.

Praktik terbaik produksi

Container image: Masukkan dependency ke dalam Docker image yang dipublikasikan daripada menginstal saat runtime. Ini memastikan reprodusibilitas dan startup lebih cepat.¹¹

Autoscaling: Aktifkan baik Ray autoscaling (menskalakan worker dalam cluster) maupun Kubernetes autoscaling (menskalakan node cluster):

spec:
  enableInTreeAutoscaling: true
  autoscalerOptions:
    upscalingMode: Default
    idleTimeoutSeconds: 60

Storage: Gunakan persistent volume untuk checkpoint dan shared storage untuk dataset besar:

volumes:
- name: shared-storage
  persistentVolumeClaim:
    claimName: ml-data-pvc

Monitoring: Integrasikan dengan Prometheus dan Grafana untuk observability:

metadata:
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "8080"

Deployment spesifik cloud

GKE: Add-on Ray on GKE menyediakan cluster Ray yang dikelola dengan provisioning otomatis dan integrasi dengan layanan Google Cloud.¹²

EKS: Deploy KubeRay dengan Cluster Autoscaler atau Karpenter untuk scaling node. Integrasi dengan FSx for Lustre menyediakan shared storage performa tinggi.

AKS: Microsoft dan Anyscale menawarkan Anyscale on Azure sebagai layanan first-party yang dapat diakses dari Azure Portal.¹³

Anyscale managed Ray

Anyscale, perusahaan yang didirikan oleh pencipta Ray, menawarkan deployment Ray yang dikelola:

Anyscale Platform

Managed cluster: Cluster Ray tingkat produksi dengan scaling otomatis, toleransi kesalahan, dan monitoring tanpa manajemen infrastruktur.

RayTurbo runtime: Peningkatan performa proprietary yang memberikan ketahanan lebih tinggi, performa lebih cepat, dan biaya lebih rendah dibandingkan Ray open-source.¹⁴

Fitur enterprise: Role-based access control, audit logging, VPC peering, dan sertifikasi compliance.

Kemitraan cloud

CoreWeave: Anyscale BYOC (Bring Your Own Cloud) melakukan deploy langsung di akun pelanggan CoreWeave melalui CoreWeave Kubernetes Service.¹⁵

Azure: Layanan Anyscale first-party tersedia di Azure Portal dengan integrasi native.

AWS: Anyscale beroperasi di AWS dengan integrasi ke layanan AWS yang ada.

Kapan menggunakan Anyscale

**Pertimbangkan Anysc