# Fim do suporte do AWS Glue para Ray
<a name="awsglue-ray-jobs-availability-change"></a>

**Importante**  
O AWS Glue para Ray não estará mais disponível 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. Para recursos semelhantes aos do AWS Glue para Ray, explore o Amazon EKS. Para saber mais, consulte [Fim do suporte do AWS Glue para Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).

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
<a name="awsglue-ray-jobs-availability-change-migration"></a>

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:
+ **Migração padrão (x86/amd64)**: para esses casos de uso, a estratégia de migração usa o contêiner OpenSource Ray para implementações básicas e executa scripts diretamente no contêiner base.
+ **Migração do ARM64**: para esses casos de uso, a estratégia de migração oferece suporte à compilação de contêineres personalizados para dependências e requisitos de arquitetura específicos do ARM64.

### Pré-requisitos para a migração
<a name="awsglue-ray-jobs-availability-change-prerequisites"></a>

Instale as seguintes ferramentas de CLI: **aws**, **kubectl**, **eksctl**, **helm** e Python 3.9\$1. 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\$1 é necessário para o próprio Ray e para executar scripts de envio de trabalhos localmente.

#### Instalar o eksctl
<a name="awsglue-ray-jobs-availability-change-install-eksctl"></a>

Siga as instruções nas [Opções de instalação do Eksctl](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html) 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
<a name="awsglue-ray-jobs-availability-change-install-kubectl"></a>

Siga as instruções em [Configurar o kubectl e o eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) 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.
<a name="awsglue-ray-jobs-availability-change-install-helm"></a>

Siga as instruções em [Instalação do Helm](https://helm.sh/docs/intro/install/) 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
<a name="awsglue-ray-jobs-availability-change-step1"></a>

**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](https://hub.docker.com/u/rayproject), por exemplo `rayproject/ray:2.4.0-py39`, que é mantida pelo projeto do Ray.

**nota**  
Essa imagem se refere somente ao amd64. Use-a se suas dependências forem compatíveis com amd64 e você não precisar de compilações específicas para ARM.

**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.
<a name="awsglue-ray-jobs-availability-change-step2"></a>

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
<a name="awsglue-ray-jobs-availability-change-job-argument-mapping"></a>


**Mapeamento de argumentos do AWS Glue para Ray para equivalentes do Ray no EKS**  

| Argumento do AWS Glue para Ray | O que isso faz no AWS Glue para Ray | Equivalente ao Ray no Amazon Elastic Kubernetes Service | 
| --- | --- | --- | 
| --min-workers | Mínimo de operadores que o trabalho deve alocar. | workerGroupSpecs[].minReplicas no seu RayCluster | 
| --working-dir | Distribui um zip (URI S3) para todos os nós. | Use o ambiente de runtime do Ray: working\$1dir se você estiver enviando a partir de arquivos locais; py\$1modules para que os zips do S3 apontem para o artefato do S3. | 
| --s3-py-modules | Adiciona arquivos wheel/dists de Python do S3. | Use o ambiente de runtime do Ray: py\$1modules: ["s3://.../xxx.whl", ...] | 
| --pip-install | Instala pacotes PyPI extras para o trabalho. | Ambiente de runtime do Ray: pip: ["pkg==ver", ...] (Ray Job CLI --runtime-env-json ou RayJob runtimeEnvYAML). | 
| --object\$1store\$1memory\$1head | Percentual de memória para o armazenamento de plasma do nó cabeça. | headGroupSpec[].rayStartParams.object-store-memory no seu RayCluster. Use bytes. AWS Glue usa percentual, ao passo que o Ray usa bytes. | 
| --object\$1store\$1memory\$1worker | Percentual de memória para o armazenamento de plasma do nó de processamento. | O mesmo que acima, mas definido no rayStartParams.object-store-memory (bytes) de cada grupo de operadores. | 
| --object\$1spilling\$1config | Configure o object spilling do Ray. | headGroupSpec[].rayStartParams.object-spilling-config | 
| --logging\$1configuration | Logs gerenciados pelo AWS Glue (CloudWatch, S3). | Verifique pod stdout/stderr: use kubectl -n ray logs <pod-name> --follow. Verifique os logs do Ray Dashboard (port-forward to :8265). Também é possível ver os logs de tarefas e trabalhos. | 

#### Mapeamento de configurações de trabalhos
<a name="awsglue-ray-jobs-availability-change-job-config-mapping"></a>


**Mapeamento das configurações de trabalho do AWS Glue para Ray para equivalentes do Ray no EKS**  

| Configuração | O que isso faz no AWS Glue para Ray | Equivalente ao Ray no EKS | 
| --- | --- | --- | 
| Tipo de operador | Defina o tipo de operador predefinido que é alocado quando um trabalho é executado. O padrão é Z 2X (8vCPU, 64 GB de RAM). | Tipo de instância do Nodegroup no EKS (por exemplo, r7g.2xlarge ≈ 8 vCPU/ 64 GB para ARM; r7a.2xlarge para x86). | 
| Número máximo de operadores | É o número de operadores que você deseja que o AWS Glue aloque para esse trabalho. | Defina workerGroupSpecs[].maxReplicas com o mesmo número que você usou em AWS Glue. Esse é o limite superior do escalonamento automático. Da mesma forma, defina minReplicas como limite inferior. Você pode começar com replicas: 0, minReplicas: 0. | 

### Etapa 3. Configuração do Amazon Elastic Kubernetes Service
<a name="awsglue-ray-jobs-availability-change-step3"></a>

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
<a name="awsglue-ray-jobs-availability-change-create-cluster"></a>

**nota**  
Se já houver um cluster do Amazon Elastic Kubernetes Service, ignore os comandos para criar um novo cluster e simplesmente adicione um grupo de nós.

```
# 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.
<a name="awsglue-ray-jobs-availability-change-add-nodegroup"></a>

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

**nota**  
Se você estiver usando um cluster atual do Amazon Elastic Kubernetes Service, use `--with-oidc` para habilitar o OIDC ao adicionar um grupo de nós.

#### Crie namespace \$1 perfil do IAM para as contas de serviço (IRSA) do S3
<a name="awsglue-ray-jobs-availability-change-irsa"></a>

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](https://docs.aws.amazon.com/eks/latest/eksctl/iamserviceaccounts.html) 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)
<a name="awsglue-ray-jobs-availability-change-install-kuberay"></a>

```
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
<a name="awsglue-ray-jobs-availability-change-step4"></a>

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
<a name="awsglue-ray-jobs-availability-change-deploy-cluster"></a>

```
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
<a name="awsglue-ray-jobs-availability-change-ray-dashboard"></a>

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
<a name="awsglue-ray-jobs-availability-change-step5"></a>

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.