

# Configurar propriedades de trabalho para trabalhos de shell Python no AWS Glue
<a name="add-job-python"></a>

 É possível usar um trabalho de shell do Python para executar scripts do Python como um shell no AWS Glue. Com uma tarefa de shell do Python, é possível executar scripts compatíveis com Python 3.6 ou Python 3.9. 

**nota**  
 O suporte para o Pyshell v3.6 terminará em 1º de março de 2026. Para migrar as workloads, consulte [Migrate from AWS Glue Python shell jobs](https://docs.aws.amazon.com/glue/latest/dg/pyshell-migration.html). Caso deseje continuar usando o shell Python v3.9, consulte [Migração do shell Python 3.6 para o shell Python 3.9](#migrating-version-pyshell36-to-pyshell39). 

**Topics**
+ [Limitações](#python-shell-limitations)
+ [Ambiente de execução](#python-shell-execution-environment)
+ [Definir propriedades de trabalho para trabalhos de shell Python](#create-job-python-properties)
+ [Bibliotecas compatíveis com trabalhos de shell Python](#python-shell-supported-library)
+ [Fornecer sua própria biblioteca Python](#create-python-extra-library)
+ [Use AWS CloudFormation com trabalhos de shell Python no AWS Glue](#python-shell-jobs-cloudformation)
+ [Migração do shell Python 3.6 para o shell Python 3.9](#migrating-version-pyshell36-to-pyshell39)
+ [Migrar dos trabalhos de shell Python no AWS Glue](pyshell-migration.md)

## Limitações
<a name="python-shell-limitations"></a>

Observe as seguintes limitações de trabalhos do shell do Python:
+  Não é possível usar marcadores de trabalho com trabalhos de shell de Python. 
+ Não é possível empacotar bibliotecas do Python como arquivos `.egg` no Python 3.9\$1. Em seu lugar, use `.whl`.
+ A opção `--extra-files` não pode ser usada devido a uma limitação de cópias temporárias de dados do S3.

## Ambiente de execução
<a name="python-shell-execution-environment"></a>

Os trabalhos de shell do Python são executados em um ambiente de execução gerenciado que fornece acesso ao armazenamento local para processamento temporário de dados:

**Armazenamento local temporário**  
O diretório `/tmp` está disponível para armazenamento temporário durante a execução do trabalho. Esse diretório fornece aproximadamente 14 GiB de espaço livre que você pode usar para:  
+ Processamento temporário de arquivos
+ Armazenamento de dados intermediário
+ Armazenamento em cache de pequenos conjuntos de dados
O diretório `/tmp` é efêmero e é limpo após a conclusão do trabalho. Não o use para armazenamento persistente de dados importantes.

## Definir propriedades de trabalho para trabalhos de shell Python
<a name="create-job-python-properties"></a>

Estas seções descrevem a definição das propriedades de trabalho no AWS Glue Studio ou usando a AWS CLI.

### AWS Glue Studio
<a name="create-job-python-properties-studio"></a>

Ao definir o trabalho de shell do Python no AWS Glue Studio, você fornece algumas das seguintes propriedades: 

**perfil do IAM**  
Especifique a função do AWS Identity and Access Management (IAM) usada para a autorização de recursos necessários ​​para a execução do trabalho e acesso ao datastore. Para obter mais informações sobre permissões de execução de trabalho no AWS Glue, consulte [Gerenciamento de identidade e acesso do AWS Glue](security-iam.md).

**Tipo**  
Selecione **Python shell (Shell do Python)** para executar um script do Python com o comando de trabalho chamado `pythonshell`.

**Versão do Python**  
Escolha a versão do Python. O padrão é o Python 3.9. As versões válidas são Python 3.6 e Python 3.9.

**Carregar bibliotecas comuns de analytics (recomendado)**  
Escolha essa opção para incluir bibliotecas comuns para Python 3.9 no shell do Python.  
Se suas bibliotecas forem personalizadas ou entrarem em conflito com as bibliotecas pré-instaladas, você poderá optar por não instalar bibliotecas comuns. No entanto, é possível instalar bibliotecas adicionais além das bibliotecas comuns.  
Ao marcar essa opção, a opção `library-set` fica definida como `analytics`. Ao desmarcar essa opção, a opção `library-set` fica definida como `none`. 

**Nome do arquivo de script e caminho do script**  
O código no script define a lógica processual do trabalho. É possível fornecer o nome e o local do script no Amazon Simple Storage Service (Amazon S3). Confirme se não existe um arquivo com o mesmo nome que o diretório do script no caminho. Para saber mais sobre como usar scripts, consulte [Guia de programação do AWS Glue](edit-script.md).

**Script**  
O código no script define a lógica processual do trabalho. Você pode codificar o script em Python 3.6 ou Python 3.9. Você pode editar um script no AWS Glue Studio.

**Unidades de processamento de dados**  
O número máximo de unidades de processamento de dados (DPUs) do AWS Glue que poderão ser alocadas quando esse trabalho for executado. Uma DPU é uma medida relativa do poder de processamento que consiste em uma capacidade computacional de 4 vCPUs e 16 GB de memória. Para obter mais informações, consulte [Preços do AWS Glue](https://aws.amazon.com/glue/pricing/).   
Você pode definir o valor como 0,0625 ou 1. O padrão é 0.0625. Em ambos os casos, o disco local da instância será de 20 GB.

### CLI
<a name="create-job-python-properties-cli"></a>

 Também é possível criar um trabalho de **Python shell (Shell do Python)** usando a AWS CLI, como no exemplo a seguir. 

```
 aws glue create-job --name python-job-cli --role Glue_DefaultRole 
     --command '{"Name" :  "pythonshell", "PythonVersion": "3.9", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'  
     --max-capacity 0.0625
```

**nota**  
 Você não precisa especificar a versão do AWS Glue, pois o parâmetro `--glue-version` não se aplica a trabalhos de shell do AWS Glue. Qualquer versão especificada será ignorada. 

 Por padrão, os trabalhos que você cria com a AWS CLI são definidos para Python 3. As versões válidas do Python são 3 (correspondendo à versão 3.6) e 3.9. Para especificar o Python 3.6, adicione a seguinte tupla ao parâmetro `--command`: `"PythonVersion":"3"` 

 Para especificar o Python 3.9, adicione a seguinte tupla ao parâmetro `--command`: `"PythonVersion":"3.9"` 

 Para definir a capacidade máxima usada por um trabalho de shell do Python, forneça o parâmetro `--max-capacity`. Para trabalhos de shell do Python, o parâmetro `--allocated-capacity` não pode ser usado. 

## Bibliotecas compatíveis com trabalhos de shell Python
<a name="python-shell-supported-library"></a>

 Ao usar o Python 3.9, você pode escolher no shell do Python o conjunto de bibliotecas para usar conjuntos pré-empacotados de bibliotecas conforme suas necessidades. Você pode usar a opção `library-set` para escolher o conjunto de bibliotecas. Os valores válidos são `analytics` e `none`. 

O ambiente para executar um trabalho de shell de Python é compatível com as seguintes bibliotecas: 


| Versão do Python | Python 3.6 | Python 3.9 | 
| --- | --- | --- | 
| Conjunto de bibliotecas | N/D | analytics | nenhuma | 
| avro |  | 1.11.0 |  | 
| awscli | 116.242 | 1.23.5 | 1.23.5 | 
| awswrangler |  | 2.15.1 |  | 
| botocore | 1.12.232 | 1.24.21 | 1.23.5 | 
| boto3 | 1.9.203 | 1.21.21 |  | 
| elasticsearch |  | 8.2.0 |  | 
| numpy | 1.16.2 | 1.22.3 |  | 
| pandas | 0.24.2 | 1.4.2 |  | 
| psycopg2 |  | 2.9.3 |  | 
| pyathena |  | 2.5.3 |  | 
| PyGreSQL | 5.0.6 |  |  | 
| PyMySQL |  | 1.0.2 |  | 
| pyodbc |  | 4.0.32 |  | 
| pyorc |  | 0.6.0 |  | 
| redshift-connector |  | 2.0.907 |  | 
| API | 2.22.0 | 2.27.1 |  | 
| scikit-learn | 0.20.3 | 1.0.2 |  | 
| scipy | 1.2.1 | 1.8.0 |  | 
| SQLAlchemy |  | 1.4.36 |  | 
| s3fs |  | 2022.3.0 |  | 

Você pode usar a biblioteca `NumPy` em um trabalho de shell do Python para computação científica. Para obter mais informações, consulte [NumPy](http://www.numpy.org). O exemplo a seguir mostra um script NumPy que pode ser usado em um trabalho de shell do Python. O script imprime "Hello world" e os resultados de vários cálculos matemáticos.

```
import numpy as np
print("Hello world")

a = np.array([20,30,40,50])
print(a)

b = np.arange( 4 )

print(b)

c = a-b

print(c)

d = b**2

print(d)
```

## Fornecer sua própria biblioteca Python
<a name="create-python-extra-library"></a>

### Usar o PIP
<a name="create-python-extra-library-pip"></a>

Ao usar o Python 3.9, o shell do Python permite que você forneça módulos adicionais ou versões diferentes do Python por trabalho. Você pode usar a opção `--additional-python-modules` 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 existente. Você não pode fornecer módulos Python personalizados hospedados no Amazon S3 com esse parâmetro ao usar trabalhos de shell do Python.

Por exemplo, para atualizar ou adicionar um novo módulo `scikit-learn`, use o seguinte par de chave e valor: `"--additional-python-modules", "scikit-learn==0.21.3"`.

AWS GlueO usa o Python Package Installer (pip3) para instalar os módulos adicionais. Você pode passar opções adicionais de pip3 dentro do valor `--additional-python-modules`. Por exemplo, `"scikit-learn==0.21.3 -i https://pypi.python.org/simple/"`. Quaisquer incompatibilidades ou limitações do pip3 se aplicam.

**nota**  
Para evitar incompatibilidades futuras, recomendamos o uso de bibliotecas compiladas para o Python 3.9.

### Usar um arquivo Egg ou Whl
<a name="create-python-extra-library-egg-whl"></a>

Talvez você já tenha uma ou mais bibliotecas Python empacotadas como um arquivo `.egg` ou `.whl`. Se esse for o caso, você poderá especificá-las para o trabalho usando a AWS Command Line Interface (AWS CLI) no sinalizador "`--extra-py-files`", como no exemplo a seguir.

```
aws glue create-job --name python-redshift-test-cli --role role --command '{"Name" :  "pythonshell", "ScriptLocation" : "s3://MyBucket/python/library/redshift_test.py"}' 
     --connections Connections=connection-name --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```

Se você não tiver certeza de como criar um arquivo `.egg` ou `.whl` de uma biblioteca Python, use as etapas a seguir. Este exemplo é aplicável a macOS, Linux e Windows Subsystem for Linux (WSL).

**Como criar um arquivo .egg ou .whl em Python**

1. Crie um cluster do Amazon Redshift em uma nuvem privada virtual (VPC) e adicione alguns dados a uma tabela.

1. Crie uma conexão do AWS Glue para a combinação VPC-GrupodeSegurança-Sub-rede que você usou para criar o cluster. Teste se a conexão foi bem-sucedida.

1. Crie um diretório chamado `redshift_example` e crie um arquivo chamado `setup.py`. Cole o seguinte código em `setup.py`.

   ```
   from setuptools import setup
   
   setup(
       name="redshift_module",
       version="0.1",
       packages=['redshift_module']
   )
   ```

1. No diretório `redshift_example`, crie um diretório `redshift_module`. No diretório `redshift_module`, crie os arquivos `__init__.py` e `pygresql_redshift_common.py`.

1. Deixe o campo `__init__.py` vazio. Em `pygresql_redshift_common.py`, cole o seguinte código: Substitua *port*, *db\$1name*, *user* e *password\$1for\$1user* por detalhes específicos do seu cluster do Amazon Redshift. Substitua *table\$1name* (nome da tabela) pelo nome da tabela no Amazon Redshift.

   ```
   import pg
   
   
   def get_connection(host):
       rs_conn_string = "host=%s port=%s dbname=%s user=%s password=%s" % (
           host, port, db_name, user, password_for_user)
   
       rs_conn = pg.connect(dbname=rs_conn_string)
       rs_conn.query("set statement_timeout = 1200000")
       return rs_conn
   
   
   def query(con):
       statement = "Select * from table_name;"
       res = con.query(statement)
       return res
   ```

1. Se você ainda não estiver lá, altere para o diretório `redshift_example`.

1. Execute um destes procedimentos:
   + Execute o seguinte comando para criar um arquivo `.egg`.

     ```
     python setup.py bdist_egg
     ```
   + Execute o seguinte comando para criar um arquivo `.whl`.

     ```
     python setup.py bdist_wheel
     ```

1. Instale as dependências necessárias para o comando anterior.

1. O comando cria um arquivo no diretório `dist`:
   + Se você criou um arquivo egg, ele se chama `redshift_module-0.1-py2.7.egg`.
   + Se você criou um arquivo wheel, ele se chama `redshift_module-0.1-py2.7-none-any.whl`.

   Faça upload desse arquivo no Amazon S3.

   Neste exemplo, o caminho do arquivo carregado é *s3://amzn-s3-demo-bucket/EGG-FILE* ou *s3://amzn-s3-demo-bucket/WHEEL-FILE*. 

1. Crie um arquivo Python para ser usado como um script para o trabalho do AWS Glue e adicione o seguinte código ao arquivo.

   ```
   from redshift_module import pygresql_redshift_common as rs_common
   
   con1 = rs_common.get_connection(redshift_endpoint)
   res = rs_common.query(con1)
   
   print "Rows in the table cities are: "
   
   print res
   ```

1. Faça o upload do arquivo anterior no Amazon S3. Neste exemplo, o caminho do arquivo carregado é *s3://amzn-s3-demo-bucket/scriptname.py*. 

1. Crie um trabalho de shell do Python usando esse script. No console do AWS Glue, na página **Job properties (Propriedades do trabalho)**, especifique o caminho para o arquivo `.egg/.whl` na caixa **Python library path (Caminho da biblioteca Python)**. Se você tiver vários arquivos `.egg/.whl` e arquivos Python, forneça uma lista separada por vírgulas nesta caixa. 

   Ao modificar ou renomear arquivos `.egg`, os nomes de arquivo devem usar os nomes padrão gerados pelo comando "python setup.py bdist\$1egg" ou devem aderir às convenções de nomenclatura do módulo Python. Para obter mais informações, consulte o [Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/). 

   Usando a AWS CLI, crie um trabalho com um comando, como no exemplo a seguir.

   ```
   aws glue create-job --name python-redshift-test-cli --role Role --command '{"Name" :  "pythonshell", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}' 
        --connections Connections="connection-name" --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
   ```

   Quando o trabalho é executado, o script imprime as linhas criadas na tabela *table\$1name* no cluster do Amazon Redshift.

## Use AWS CloudFormation com trabalhos de shell Python no AWS Glue
<a name="python-shell-jobs-cloudformation"></a>

 Você pode usar AWS CloudFormation com trabalhos de shell Python no AWS Glue. Este é um exemplo: 

```
AWSTemplateFormatVersion: 2010-09-09
Resources:
  Python39Job:
    Type: 'AWS::Glue::Job'
    Properties:
      Command:
        Name: pythonshell
        PythonVersion: '3.9'
        ScriptLocation: 's3://bucket/location'
      MaxRetries: 0
      Name: python-39-job
      Role: RoleName
```

 O grupo do Amazon CloudWatch Logs para a saída de trabalhos de shell do Python é `/aws-glue/python-jobs/output`. Para erros, consulte o grupo de logs `/aws-glue/python-jobs/error`. 

## Migração do shell Python 3.6 para o shell Python 3.9
<a name="migrating-version-pyshell36-to-pyshell39"></a>

 Para migrar seus trabalhos do shell Python para a versão mais recente do AWS Glue: 

1.  No console do AWS Glue ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), escolha seu trabalho de shell Python existente. 

1.  Na guia de detalhes do **Trabalho**, defina a versão do Python como `Python 3.9` e clique em **Salvar**. 

1.  Certifique-se de que o script do trabalho seja compatível com o Python 3.9 e que ele pode ser executado com êxito. 