Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

AWS Glue untuk Ray akhir dukungan

Setelah mempertimbangkan dengan cermat, kami memutuskan AWS Glue untuk menutup Ray ke pelanggan baru mulai 30 April 2026. Jika Anda ingin menggunakan AWS Glue untuk Ray, daftar sebelum tanggal tersebut. Pelanggan yang sudah ada dapat terus menggunakan layanan ini seperti biasa.

AWS terus berinvestasi dalam peningkatan keamanan dan ketersediaan untuk AWS Glue untuk Ray. Perhatikan bahwa kami tidak berencana untuk memperkenalkan fitur baru AWS Glue untuk Ray, kecuali untuk peningkatan keamanan dan ketersediaan.

Sebagai alternatif AWS Glue untuk Ray, sebaiknya gunakan Amazon Elastic Kubernetes Service. Amazon Elastic Kubernetes Service adalah layanan kesesuaian Kubernetes yang dikelola sepenuhnya dan bersertifikat yang menyederhanakan proses pembuatan, pengamanan, pengoperasian, dan pemeliharaan klaster Kubernetes. AWS Ini adalah opsi yang sangat dapat disesuaikan yang mengandalkan KubeRay Operator open-source untuk menyebarkan dan mengelola cluster Ray di Kubernetes, menawarkan pemanfaatan sumber daya yang ditingkatkan, manajemen infrastruktur yang disederhanakan, dan dukungan penuh untuk fitur Ray.

Migrasi pekerjaan Ray ke Amazon Elastic Kubernetes Service

Bagian ini menyediakan langkah-langkah untuk bermigrasi dari AWS Glue untuk Ray ke Ray di Amazon Elastic Kubernetes Service. Langkah-langkah ini berguna untuk dua skenario migrasi:

Prasyarat untuk migrasi

Instal alat CLI berikut:aws,,, kubectleksctl, helm Python 3.9+. Alat CLI ini diperlukan untuk menyediakan dan mengelola lingkungan Ray on EKS Anda. eksctlmenyederhanakan pembuatan dan pengelolaan kluster EKS. kubectladalah CLI Kubernetes standar untuk menerapkan dan memecahkan masalah beban kerja di cluster Anda. helmdigunakan untuk menginstal dan mengelola KubeRay (operator yang menjalankan Ray di Kubernetes). Python 3.9+ diperlukan untuk Ray itu sendiri dan untuk menjalankan skrip pengiriman pekerjaan secara lokal.

Instal eksctl

Ikuti petunjuk pada opsi Instalasi untuk Eksctl atau gunakan petunjuk di bawah ini untuk instalasi.

Untuk macOS:

brew tap weaveworks/tap
brew install weaveworks/tap/eksctl

Untuk Linux:

curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

# Move the extracted binary to /usr/local/bin
sudo mv /tmp/eksctl /usr/local/bin

# Test the installation
eksctl version

Instal kubectl

Ikuti petunjuk pada Mengatur kubectl dan eksctl atau gunakan petunjuk di bawah ini untuk instalasi.

Untuk macOS:

brew install kubectl

Untuk Linux:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

Instal helm

Ikuti petunjuk pada Instalasi Helm atau gunakan petunjuk di bawah ini untuk instalasi.

Untuk macOS:

brew install helm

Untuk Linux:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Langkah 1. Buat atau pilih Gambar Docker untuk Ray

Opsi 1: Gunakan gambar Ray resmi (tidak diperlukan build)

Opsi ini menggunakan gambar Ray Docker resmi di Docker Hub, misalnyarayproject/ray:2.4.0-py39, yang dikelola oleh proyek Ray.

Opsi 2: Bangun dan publikasikan gambar arm64 Ray 2.4.0 Anda sendiri

Opsi ini berguna saat menggunakan node Graviton (ARM), konsisten dengan apa yang digunakan Ray AWS Glue secara internal. Anda dapat membuat gambar kustom yang disematkan ke versi dependensi yang sama seperti AWS Glue untuk Ray, untuk mengurangi ketidakcocokan kompatibilitas.

Buat Dockerfile secara lokal:

# Build an ARM64 image
FROM --platform=linux/arm64 python:3.9-slim-bullseye
# Handy tools: wget for KubeRay probes; CA certs; keep image small
RUN apt-get update && apt-get install -y --no-install-recommends \
    wget ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# Keep pip/setuptools modern enough for wheels resolution
RUN python -m pip install -U "pip<24" "setuptools<70" wheel

# ---- Install Ray 2.4.0 (ARM64 / Py3.9) and Glue-like dependencies ----
# 1) Download the exact Ray 2.4.0 wheel for aarch64 (no network at runtime)
RUN python -m pip download --only-binary=:all: --no-deps --dest /tmp/wheels ray==2.4.0

# 2) Core libs used in Glue (pin to Glue-era versions)
#    + the dashboard & jobs API dependencies compatible with Ray 2.4.0.
#    (Pins matter: newer major versions break 2.4.0's dashboard.)
RUN python -m pip install --no-cache-dir \
    /tmp/wheels/ray-2.4.0-*.whl \
    "pyarrow==11.0.0" \
    "pandas==1.5.3" \
    "boto3==1.26.133" \
    "botocore==1.29.133" \
    "numpy==1.24.3" \
    "fsspec==2023.4.0" \
    "protobuf<4" \
    # --- dashboard / jobs server deps ---
    "aiohttp==3.8.5" \
    "aiohttp-cors==0.7.0" \
    "yarl<1.10" "multidict<7.0" "frozenlist<1.4" "aiosignal<1.4" "async_timeout<5" \
    "pydantic<2" \
    "opencensus<0.12" \
    "prometheus_client<0.17" \
    # --- needed if using py_modules ---
    "smart_open[s3]==6.4.0"

# Optional: prove Ray & arch at container start
ENV PYTHONUNBUFFERED=1
WORKDIR /app

# KubeRay overrides the start command; this is just a harmless default
CMD ["python","-c","import ray,platform; print('Ray', ray.__version__, 'on', platform.machine())"]

# Set environment variables
export AWS_REGION=us-east-1
export AWS_ACCOUNT=$(aws sts get-caller-identity --query Account --output text)
export REPO=ray-2-4-arm64
export IMAGE=${AWS_ACCOUNT}.dkr.ecr.${AWS_REGION}.amazonaws.com/${REPO}:v1

# Create repository and login
aws ecr create-repository --repository-name $REPO >/dev/null 2>&1 || true
aws ecr get-login-password --region $AWS_REGION \
  | docker login --username AWS --password-stdin ${AWS_ACCOUNT}.dkr.ecr.${AWS_REGION}.amazonaws.com

# Enable Buildx (for cross-builds on non-ARM hosts)
docker buildx create --name multi --driver docker-container --use 2>/dev/null || true

# Build & push ARM64 image
docker buildx build \
  --platform linux/arm64 \
  -t "$IMAGE" \
  . --push

# Verify the image architecture remotely
aws ecr batch-get-image \
  --repository-name $REPO \
  --image-ids imageTag=v1 \
  --accepted-media-types application/vnd.docker.distribution.manifest.v2+json \
  | jq -r '.images[0].imageManifest' \
  | jq -r 'fromjson.config.digest'

Setelah selesai, rujuk ARM64 gambar ini dalam RayCluster spesifikasi dengannodeSelector: { kubernetes.io/arch: arm64 }.

spec:
  rayVersion: "2.4.0"
  headGroupSpec:
    template:
      spec:
        containers:
        - name: ray-head
          image: <your ECR image>

Langkah 2. Konversi AWS Glue untuk Konfigurasi Pekerjaan Ray ke Ray di Amazon Elastic Kubernetes Service

AWS Glue untuk pekerjaan Ray mendukung serangkaian argumen pekerjaan yang mengonfigurasi pekerja, dependensi, memori, dan logging. Saat bermigrasi ke Amazon Elastic Kubernetes KubeRay Service dengan, argumen ini perlu diterjemahkan RayCluster ke dalam bidang spesifikasi atau pengaturan lingkungan runtime Ray Job.

Pemetaan Argumen Job

Pemetaan Konfigurasi Pekerjaan

Langkah 3. Siapkan Layanan Amazon Elastic Kubernetes

Anda dapat membuat cluster Amazon Elastic Kubernetes Service baru atau menggunakan kembali cluster Amazon Elastic Kubernetes Service yang sudah ada. Jika menggunakan cluster yang ada, lewati perintah create cluster dan lompat ke Tambahkan grup node, IRSA, dan instal KubeRay.

Buat kluster Amazon Elastic Kubernetes Service

# Environment Variables
export AWS_REGION=us-east-1
export CLUSTER=ray-eks
export NS=ray # namespace for your Ray jobs (you can reuse another if you like)

# Create a cluster (OIDC is required for IRSA)
eksctl create cluster \
  --name $CLUSTER \
  --region $AWS_REGION \
  --with-oidc \
  --managed

Tambahkan grup simpul

# ARM/Graviton (matches Glue's typical runtime):
eksctl create nodegroup \
  --cluster $CLUSTER \
  --region $AWS_REGION \
  --name arm64-ng \
  --node-type m7g.large \
  --nodes 2 --nodes-min 1 --nodes-max 5 \
  --managed \
  --node-labels "workload=ray"

# x86/amd64 (use if your image is amd64-only):
eksctl create nodegroup \
  --cluster $CLUSTER \
  --region $AWS_REGION \
  --name amd64-ng \
  --node-type m5.large \
  --nodes 2 --nodes-min 1 --nodes-max 5 \
  --managed \
  --node-labels "workload=ray"

Buat namespace+peran IAM untuk Akun Layanan (IRSA) untuk S3

Namespace Kubernetes adalah pengelompokan logis untuk sumber daya (pod, layanan, peran, dll.). Anda dapat membuat atau menggunakan kembali namespace yang ada. Anda juga perlu membuat kebijakan IAM untuk S3 yang mencerminkan akses AWS Glue pekerjaan Anda. Gunakan izin kustom yang sama dengan peran AWS Glue pekerjaan Anda (biasanya S3 read/write ke bucket tertentu). Untuk memberikan izin ke Amazon Elastic Kubernetes Service yang serupa dengan, buat Akun Layanan ( AWSGlueServiceRoleIRSA) yang terikat pada kebijakan IAM ini. Lihat Peran IAM untuk Akun Layanan untuk petunjuk penyiapan akun layanan ini.

# Create (or reuse) namespace
kubectl create namespace $NS || true

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:PutObject", "s3:GetObject", "s3:ListBucket"],
    "Resource": [
      "arn:aws:s3:::YOUR-BUCKET",
      "arn:aws:s3:::YOUR-BUCKET/*"
    ]
  }]
}

# Create the IAM policy and wire IRSA:
aws iam create-policy \
  --policy-name RayS3Policy \
  --policy-document file://example.json || true

# Create a service account (IRSA) bound to that policy.
eksctl create iamserviceaccount \
  --cluster $CLUSTER \
  --region $AWS_REGION \
  --namespace $NS \
  --name ray-s3-access \
  --attach-policy-arn arn:aws:iam::${AWS_ACCOUNT}:policy/RayS3Policy \
  --approve \
  --override-existing-serviceaccounts

Instal KubeRay operator (pengontrol yang menjalankan Ray pada K8s)

helm repo add kuberay https://ray-project.github.io/kuberay-helm/
helm repo update
helm upgrade --install kuberay-operator kuberay/kuberay-operator \
  --namespace kuberay-system \
  --create-namespace

# Validate the operator pod Running
kubectl -n kuberay-system get pods

Langkah 4. Putar cluster Ray

Buat file YAMG untuk menentukan ray cluster. Di bawah ini adalah contoh konfigurasi (raycluster.yaml):

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: glue-like
  namespace: ray
spec:
  rayVersion: "2.4.0"
  headGroupSpec:
    template:
      spec:
        nodeSelector:
          kubernetes.io/arch: amd64
        serviceAccountName: ray-s3-access
        containers:
        - name: ray-head
          image: rayproject/ray:2.4.0-py39
          imagePullPolicy: Always
          resources:
            requests: { cpu: "1", memory: "2Gi" }
            limits:   { cpu: "1", memory: "2Gi" }
  workerGroupSpecs:
  - groupName: workers
    replicas: 0 # start with just a head (like small Glue dev job) and turn number of replicas later
    minReplicas: 0
    maxReplicas: 5
    template:
      spec:
        nodeSelector:
          kubernetes.io/arch: amd64
        serviceAccountName: ray-s3-access
        containers:
        - name: ray-worker
          image: rayproject/ray:2.4.0-py39
          imagePullPolicy: Always
          resources:
            requests: { cpu: "1", memory: "2Gi" }
            limits:   { cpu: "1", memory: "2Gi" }

Menerapkan cluster Ray di kluster Amazon Elastic Kubernetes Service

kubectl apply -n $NS -f raycluster.yaml

# Validate that the head pod turns to READY/ RUNNING state
kubectl -n $NS get pods -l ray.io/cluster=glue-like -w

Jika ada kebutuhan untuk memodifikasi yaml yang diterapkan, hapus cluster terlebih dahulu lalu terapkan kembali yaml yang diperbarui:

kubectl -n $NS delete raycluster glue-like
kubectl -n $NS apply -f raycluster.yaml

Mengakses Dasbor Ray

Anda dapat mengakses dasbor Ray dengan mengaktifkan port-forwarding menggunakan kubectl:

# Get service
SVC=$(kubectl -n $NS get svc -l ray.io/cluster=glue-like,ray.io/node-type=head -o jsonpath='{.items[0].metadata.name}')

# Make the Ray dashboard accessible at http://localhost:8265 on your local machine.
kubectl -n $NS port-forward svc/$SVC 8265:8265

Langkah 5. Kirim Ray Job

Untuk mengirimkan pekerjaan Ray, gunakan CLI pekerjaan Ray. Versi CLI bisa lebih baru dari cluster, kompatibel ke belakang. Sebagai prasyarat, simpan skrip pekerjaan Anda secara lokal dalam file, mis. job.py

python3 -m venv ~/raycli && source ~/raycli/bin/activate
pip install "ray[default]==2.49.2"

# Submit your ray job by supplying all python dependencies that was added to your Glue job
ray job submit --address http://127.0.0.1:8265 --working-dir . \
  --runtime-env-json '{
    "pip": ["boto3==1.28.*","pyarrow==12.*","pandas==2.0.*"]
  }' \
  -- python job.py

Pekerjaan dapat dipantau di dasbor Ray.