Fim do suporte do AWS Glue para Ray

Após uma análise cuidadosa, decidimos encerrar o AWS Glue para Ray para novos clientes a partir de 30 de abril de 2026. Se quiser usar o AWS Glue para Ray, inscreva-se antes dessa data. Os clientes atuais podem continuar usando o serviço normalmente.

A AWS continua investindo em melhorias de segurança e disponibilidade do AWS Glue para Ray. Não planejamos introduzir novos atributos no AWS Glue para Ray, exceto em termos de aprimoramentos de segurança e disponibilidade.

Como alternativa ao AWS Glue para Ray, recomendamos o uso do Amazon Elastic Kubernetes Service. O Amazon Elastic Kubernetes Service é um serviço totalmente gerenciado e certificado em conformidade com o serviço Kubernetes que simplifica o processo de compilar, proteger, operar e manter clusters do Kubernetes na AWS. Essa é uma opção altamente personalizável que depende do KubeRay Operator de código aberto para implantar e gerenciar clusters do Ray no Kubernetes, oferecendo melhor utilização de recursos, gerenciamento simplificado da infraestrutura e suporte total aos atributos do Ray.

Migração de um trabalho do Ray para o Amazon Elastic Kubernetes Service

Esta seção descreve as etapas para a migração do AWS Glue para Ray para o Ray no Amazon Elastic Kubernetes Service. Essas etapas são úteis para dois cenários de migração:

Pré-requisitos para a migração

Instale as seguintes ferramentas de CLI: aws, kubectl, eksctl, helm e Python 3.9+. Essas ferramentas de CLI são necessárias para provisionar e gerenciar seu ambiente Ray no EKS. O eksctl simplifica a criação e o gerenciamento de clusters do EKS. kubectl é a CLI padrão do Kubernetes para implantar e solucionar problemas de worloads em seu cluster. helm é usado para instalar e gerenciar o KubeRay (operador que executa o Ray no Kubernetes). Python 3.9+ é necessário para o próprio Ray e para executar scripts de envio de trabalhos localmente.

Instalar o eksctl

Siga as instruções nas Opções de instalação do Eksctl ou use as instruções abaixo para a instalação.

Para macOS:

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

Para 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

Instalar o kubectl

Siga as instruções em Configurar o kubectl e o eksctl ou use as instruções abaixo para a instalação.

Para macOS:

brew install kubectl

Para 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/

Instale o Helm.

Siga as instruções em Instalação do Helm ou use as instruções abaixo para a instalação.

Para macOS:

brew install helm

Para Linux:

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

Etapa 1. Crie ou escolha uma imagem do Docker para o Ray

Opção 1: usar a imagem oficial do Ray (sem necessidade de compilação)

Essa opção usa a imagem oficial do Docker do Ray no Docker Hub, por exemplo rayproject/ray:2.4.0-py39, que é mantida pelo projeto do Ray.

Opção 2: criar e publicar sua própria imagem arm64 para Ray 2.4.0

Essa opção é útil ao usar nós Graviton (ARM), consistentes com o que o AWS Glue para Ray usa internamente. Você pode criar uma imagem personalizada fixada nas mesmas versões de dependência do AWS Glue para Ray para reduzir incompatibilidades.

Crie um arquivo do Docker localmente.

# 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'

Em seguida, faça referência a essa imagem ARM64 na especificação do RayCluster com nodeSelector: { kubernetes.io/arch: arm64 }.

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

Etapa 2. Converta a configuração de trabalhos do AWS Glue para Ray para o Ray no Amazon Elastic Kubernetes Service.

Os trabalhos do AWS Glue para Ray são compatíveis com um conjunto de argumentos de trabalho que configuram operadores, dependências, memória e registros em log. Ao migrar para o Amazon Elastic Kubernetes Service com o KubeRay, esses argumentos precisam ser traduzidos em campos de especificação do RayCluster ou configurações do ambiente de runtime dos trabalhos do Ray.

Mapeamento de argumentos de trabalhos

Mapeamento de configurações de trabalhos

Etapa 3. Configuração do Amazon Elastic Kubernetes Service

Você pode criar um novo cluster do Amazon Elastic Kubernetes Service ou reutilizar um cluster atual do Amazon Elastic Kubernetes Service. Se estiver usando um cluster atual, pule os comandos de criação de cluster e vá para Adicionar um grupo de nós, IRSA e instalar o KubeRay.

Crie um cluster do 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

Adicione um grupo de nós.

# 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"

Crie namespace + perfil do IAM para as contas de serviço (IRSA) do S3

Um namespace Kubernetes é um agrupamento lógico de recursos (pods, serviços, perfis, etc.). Você pode criar ou reutilizar um namespace atual. Você também precisa criar uma política do IAM para o S3 que espelhe o acesso aos trabalhos do AWS Glue. Use as mesmas permissões personalizadas usadas pelo seu perfil de trabalho do AWS Glue (normalmente leitura/gravação do S3 em buckets específicos). Para conceder permissões semelhantes a AWSGlueServiceRole para o Amazon Elastic Kubernetes Service, crie uma conta de serviço (IRSA) vinculada a essa política do IAM. Consulte Perfis do IAM para contas de serviço para obter instruções sobre como configurar essa conta de serviço.

# 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

Instale o operador KubeRay (controlador que executa o Ray em 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

Etapa 4: Crie um cluster do Ray

Crie um arquivo do YAML para definir o cluster do Ray. Abaixo, um exemplo de configuração (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" }

Implante o cluster do Ray no cluster do 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

Se houver necessidade de modificar o yaml implantado, primeiramente exclua o cluster e depois aplique novamente o yaml atualizado:

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

Acesso ao painel do Ray

Você pode acessar o painel do Ray ativando o encaminhamento de portas usando 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

Etapa 5. Envio de trabalhos do Ray

Para enviar um trabalho do Ray, use a CLI de trabalhos do Ray. A versão da CLI pode ser mais recente que a do cluster; ela é compatível com versões anteriores. Como pré-requisito, armazene seu script de trabalho localmente em um arquivo, por exemplo 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

O trabalho pode ser monitorado no painel do Ray.