# Chamar APIs do AWS Glue no Python
<a name="aws-glue-programming-python-calling"></a>

Observação: as APIs de recursos do Boto 3 ainda não estão disponíveis no AWS Glue. Atualmente, apenas as APIs de cliente do Boto 3 podem ser usadas.

## Nomes de API do AWS Glue em Python
<a name="aws-glue-programming-python-calling-names"></a>

AWSOs nomes de API do Glue em Java e em outras linguagens de programação geralmente misturam letras maiúsculas e minúsculas. No entanto, quando chamados no Python, esses nomes genéricos são alterados para minúsculas, com partes do nome separadas por caracteres de sublinhado para deixá-los com uma aparência mais familiar para usuários do Python. Na documentação de referência da [API AWS Glue](aws-glue-api.md), esses nomes do Python estão listados entre parênteses, após os nomes genéricos com letras minúsculas e maiúsculas misturadas.

Embora as letras dos nomes de API do AWS Glue sejam transformadas em minúsculas, seus nomes de parâmetros permanecem em letras maiúsculas. Lembre-se disso porque os parâmetros devem ser transmitidos pelo nome ao chamar APIs do AWS Glue, conforme descrito na seção a seguir.

## Transmitir e acessar parâmetros de Python no AWS Glue
<a name="aws-glue-programming-python-calling-parameters"></a>

Nas chamadas do Python para APIs do AWS Glue, é melhor transmitir os parâmetros explicitamente por nome. Por exemplo:

```
job = glue.create_job(Name='sample', Role='Glue_DefaultRole',
                      Command={'Name': 'glueetl',
                               'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'})
```

O Python cria um dicionário das tuplas de nome/valor que você especifica como argumentos para um script de ETL em um [Estrutura do trabalho](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) ou [Estrutura JobRun](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-JobRun). Em seguida, o Boto 3 transmite para o AWS Glue no formato JSON por meio de uma chamada de API REST. Isso significa que você não pode confiar na ordem dos argumentos ao acessá-los no seu script.

Por exemplo, suponha que você esteja iniciando um `JobRun` em uma função de handler Lambda do Python e queira especificar vários parâmetros. Seu código será parecido com este:

```
from datetime import datetime, timedelta

client = boto3.client('glue')

def lambda_handler(event, context):
  last_hour_date_time = datetime.now() - timedelta(hours = 1)
  day_partition_value = last_hour_date_time.strftime("%Y-%m-%d")
  hour_partition_value = last_hour_date_time.strftime("%-H")

  response = client.start_job_run(
               JobName = 'my_test_Job',
               Arguments = {
                 '--day_partition_key':   'partition_0',
                 '--hour_partition_key':  'partition_1',
                 '--day_partition_value':  day_partition_value,
                 '--hour_partition_value': hour_partition_value } )
```

Para acessar esses parâmetros de forma confiável no seu script de ETL, especifique-os pelo nome usando a função AWS Glue do `getResolvedOptions` e, em seguida, acesse-os no dicionário resultante:

```
import sys
from awsglue.utils import getResolvedOptions

args = getResolvedOptions(sys.argv,
                          ['JOB_NAME',
                           'day_partition_key',
                           'hour_partition_key',
                           'day_partition_value',
                           'hour_partition_value'])
print "The day partition key is: ", args['day_partition_key']
print "and the day partition value is: ", args['day_partition_value']
```

Se você quiser transmitir um argumento que seja uma string JSON aninhada, para preservar o valor do parâmetro à medida que ele é transmitido para o seu trabalho de ETL do AWS Glue, você deve codificar a string de parâmetro antes de iniciar a execução do trabalho e, em seguida, decodificar a string de parâmetro antes de fazer referência ao script de trabalho. Por exemplo, considere a seguinte string de argumento:

```
glue_client.start_job_run(JobName = "gluejobname", Arguments={
"--my_curly_braces_string": '{"a": {"b": {"c": [{"d": {"e": 42}}]}}}'
})
```

Para transmitir esse parâmetro corretamente, você deve codificar o argumento como uma string codificada em Base64.

```
import base64
...
sample_string='{"a": {"b": {"c": [{"d": {"e": 42}}]}}}'
sample_string_bytes = sample_string.encode("ascii")

base64_bytes = base64.b64encode(sample_string_bytes) 
base64_string = base64_bytes.decode("ascii") 
...
glue_client.start_job_run(JobName = "gluejobname", Arguments={
"--my_curly_braces_string": base64_bytes})
...
sample_string_bytes = base64.b64decode(base64_bytes) 
sample_string = sample_string_bytes.decode("ascii") 
print(f"Decoded string: {sample_string}") 
...
```

## Exemplo: criar e executar um trabalho
<a name="aws-glue-programming-python-calling-example"></a>

O exemplo a seguir mostra como chamar APIs do AWS Glue usando Python para criar e executar um trabalho de ETL.

**Para criar e executar um trabalho**

1. Crie uma instância do cliente AWS Glue:

   ```
   import boto3
   glue = boto3.client(service_name='glue', region_name='us-east-1',
                 endpoint_url='https://glue.us-east-1.amazonaws.com')
   ```

1. Crie um trabalho. Você precisa usar `glueetl` como o nome do comando de ETL, conforme mostrado no código a seguir:

   ```
   myJob = glue.create_job(Name='sample', Role='Glue_DefaultRole',
                             Command={'Name': 'glueetl',
                                      'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'})
   ```

1. Inicie uma nova execução do trabalho que você criou na etapa anterior:

   ```
   myNewJobRun = glue.start_job_run(JobName=myJob['Name'])
   ```

1. Veja o status do trabalho:

   ```
   status = glue.get_job_run(JobName=myJob['Name'], RunId=myNewJobRun['JobRunId'])
   ```

1. Imprima o estado atual da execução do trabalho:

   ```
   print(status['JobRun']['JobRunState'])
   ```