Módulos fornecidos com trabalhos do Ray Fornecer arquivos para o trabalho do Ray Módulos adicionais do Python para trabalhos do Ray Incluir código do Python em trabalhos do Ray

Fornecer arquivos e bibliotecas do Python para trabalhos do Ray

Esta seção fornece as informações de que você precisa para usar as bibliotecas do Python com trabalhos do AWS Glue Ray. Você pode usar determinadas bibliotecas comuns incluídas por padrão em todos os trabalhos do Ray. Você também pode fornecer suas próprias bibliotecas do Python para seu trabalho do Ray.

Módulos fornecidos com trabalhos do Ray

Você pode executar fluxos de trabalho de integração de dados em um trabalho do Ray com os seguintes pacotes fornecidos. Esses pacotes estão disponíveis por padrão nos trabalhos do Ray.

Fornecer arquivos para o trabalho do Ray

Você pode fornecer arquivos para o trabalho do Ray com o parâmetro --working-dir. Forneça a esse parâmetro um caminho para um arquivo.zip hospedado no Amazon S3. Dentro arquivo.zip, os arquivos devem estar contidos em um único diretório de nível superior. Nenhum outro arquivo deve estar no nível superior.

Os arquivos serão distribuídos para cada nó do Ray antes que o script comece a ser executado. Considere como isso pode afetar o espaço em disco disponível para cada nó do Ray. O espaço em disco disponível é determinado pelo WorkerType definido na configuração do trabalho. Se você quiser fornecer os dados do trabalho em grande escala, esse mecanismo não é a solução certa. Para obter mais informações sobre fornecimento de dados no trabalho, consulte Conectar a dados em trabalhos do Ray.

Os arquivos estarão acessíveis como se o diretório tivesse sido fornecido ao Ray por meio do parâmetro working_dir. Por exemplo, para ler um arquivo denominado sample.txt no diretório de nível superior do arquivo.zip, você pode chamar:


@ray.remote
def do_work():
    f = open("sample.txt", "r")
    print(f.read())

Para obter mais informações sobre o working_dir, consulte a documentação do Ray. Esse atributo se comporta de modo semelhante aos recursos nativos do Ray.

Módulos adicionais do Python para trabalhos do Ray

Módulos adicionais do PyPI

Os trabalhos do Ray usam o pacote de instalação do Python (pip3) para instalar módulos adicionais a serem usados por um script do Ray. Você pode usar o parâmetro --pip-install com uma lista de módulos do Python separados por vírgulas para adicionar um novo módulo ou alterar a versão de um módulo existente.

Por exemplo, para atualizar ou adicionar um novo módulo scikit-learn, use o seguinte par chave-valor:

"--pip-install", "scikit-learn==0.21.3"

Se você tiver módulos personalizados ou patches personalizados, poderá distribuir suas próprias bibliotecas do Amazon S3 com o parâmetro --s3-py-modules. Antes de carregar a distribuição, pode ser necessário reempacotá-la e recompilá-la. Siga as diretrizes em Incluir código do Python em trabalhos do Ray.

Distribuições personalizadas a partir do Amazon S3

As distribuições personalizadas devem seguir as diretrizes de empacotamento do Ray para dependências. Você pode descobrir como compilar essas distribuições na seção a seguir. Para obter mais informações sobre como o Ray configura dependências, consulte Environment Dependencies (Dependências de ambiente) na documentação do Ray.

Para incluir um distribuível personalizado após avaliar seu conteúdo, carregue o distribuível em um bucket disponível para o perfil do IAM do trabalho. Especifique o caminho do Amazon S3 para um arquivo zip do Python na configuração de parâmetros. Se você estiver fornecendo vários itens distribuíveis, separe-os por vírgulas. Por exemplo:

"--s3-py-modules", "s3://s3bucket/pythonPackage.zip"

Limitações

Os trabalhos do Ray não são compatíveis com a compilação de código nativo no ambiente de trabalho. Você poderá ser limitado por isso se as dependências do Python dependerem transitivamente do código nativo compilado. Os trabalhos do Ray podem executar os binários fornecidos, mas eles devem ser compilados para Linux no ARM64. Isso significa que você poderá usar o conteúdo as rodas aarch64manylinux. Você pode fornecer as dependências nativas em formato compilado reempacotando uma roda de acordo com os padrões do Ray. Normalmente, isso significa remover as pastas dist-info para que haja apenas uma pasta na raiz no arquivo compactado.

Você não pode atualizar a versão do ray ou do ray[data] usando esse parâmetro. Para usar uma nova versão do Ray, você precisará alterar o campo de runtime no trabalho, após lançarmos a compatibilidade com ele. Para obter mais informações sobre as versões compatíveis do Ray, consulte Versões do AWS Glue.

Incluir código do Python em trabalhos do Ray

A Python Software Foundation oferece comportamentos padronizados para empacotar arquivos do Python para uso em diferentes runtimes. O Ray introduz limitações aos padrões de empacotamento que você deve conhecer. O AWS Glue não especifica padrões de empacotamento além dos especificados para o Ray. As instruções a seguir fornecem orientação padrão sobre o empacotamento de pacotes simples do Python.

Empacotar arquivos em um arquivo compactado .zip. Um diretório deve estar na raiz do raiz do arquivo compactado. Não deve haver outros arquivos no nível raiz do arquivo compactado, ou isso pode causar um comportamento inesperado. O diretório raiz é o pacote, e o nome dele é usado para se referir ao código do Python ao importá-lo.

Se fornecer um pacote nesse formato para um trabalho do Ray com --s3-py-modules, você poderá importar código do Python do pacote no script do Ray.

O pacote pode fornecer um único módulo do Python com alguns arquivos do Python, ou você pode empacotar vários módulos juntos. Ao reempacotar dependências, como bibliotecas do PyPI, verifique se há arquivos e diretórios de metadados ocultos dentro desses pacotes.

Atenção

Certos comportamentos do sistema operacional dificultam o cumprimento adequado dessas instruções de empacotamento.

O OSX pode adicionar arquivos ocultos, como __MACOSX no arquivo zip no nível superior.
O Windows pode adicionar os arquivos em uma pasta dentro do zip automaticamente, criando involuntariamente uma pasta aninhada.

Os procedimentos a seguir pressupõem que você esteja interagindo com os arquivos no Amazon Linux 2 ou em um sistema operacional similar que forneça uma distribuição do Info-ZIP zip e dos utilitários zipinfo. Recomendamos o uso dessas ferramentas para evitar comportamentos inesperados.

Para empacotar arquivos do Python para uso no Ray

Crie um diretório temporário com o nome do pacote e confirme se o diretório de trabalho é o diretório principal. É possível fazer isso com os seguintes comandos:
```
cd parent_directory
mkdir temp_dir
```
Copie os arquivos no diretório temporário e confirme a estrutura de diretórios. O conteúdo desse diretório será acessado diretamente como seu módulo do Python. É possível fazer isso com o seguinte comando da :
```
ls -AR temp_dir
# my_file_1.py
# my_file_2.py
```
Compacte a pasta temporária usando zip. É possível fazer isso com os seguintes comandos:
```
zip -r zip_file.zip temp_dir
                
```
Confirme se o arquivo está devidamente empacotado. O zip_file.zip agora deve ser encontrado em seu diretório de trabalho. É possível inspecioná-lo com o seguinte comando:
```
zipinfo -1 zip_file.zip
# temp_dir/
# temp_dir/my_file_1.py
# temp_dir/my_file_2.py
```

Para reempacotar um pacote do Python para uso no Ray.

Crie um diretório temporário com o nome do pacote e confirme se o diretório de trabalho é o diretório principal. É possível fazer isso com os seguintes comandos:
```
cd parent_directory
mkdir temp_dir
```
Descompacte o pacote e copie seu conteúdo no diretório temporário. Remova arquivos relacionados ao padrão de empacotamento anterior, deixando somente o conteúdo do módulo. Confirme se a estrutura do arquivo está correta com o seguinte comando:
```
ls -AR temp_dir
# my_module
# my_module/__init__.py
# my_module/my_file_1.py
# my_module/my_submodule/__init__.py
# my_module/my_submodule/my_file_2.py
# my_module/my_submodule/my_file_3.py
```
Compacte a pasta temporária usando zip. É possível fazer isso com os seguintes comandos:
```
zip -r zip_file.zip temp_dir
                
```

Confirme se o arquivo está devidamente empacotado. O zip_file.zip agora deve ser encontrado em seu diretório de trabalho. É possível inspecioná-lo com o seguinte comando:


zipinfo -1 zip_file.zip
# temp_dir/my_module/
# temp_dir/my_module/__init__.py
# temp_dir/my_module/my_file_1.py
# temp_dir/my_module/my_submodule/
# temp_dir/my_module/my_submodule/__init__.py
# temp_dir/my_module/my_submodule/my_file_2.py
# temp_dir/my_module/my_submodule/my_file_3.py

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar o Ray Core e o Ray Data no AWS Glue para Ray

Conectar-se a dados