As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Convertendo processos ETL em in AWS Glue AWS Schema Conversion Tool
<a name="CHAP-converting-aws-glue-api-process"></a>

Nas seções a seguir, você encontrará uma descrição de uma conversão que chama operações de AWS Glue API em Python. Para obter mais informações, consulte [Programar scripts de ETL do AWS Glue em Python](https://docs.aws.amazon.com//glue/latest/dg/aws-glue-programming-python.html) no *Guia do desenvolvedor do AWS Glue *.

**Topics**
+ [Etapa 1: criar um banco de dados](#CHAP-converting-aws-glue-step-api-create-db)
+ [Etapa 2: criar uma conexão](#CHAP-converting-aws-glue-step-api-connection)
+ [Etapa 3: criar um AWS Glue rastreador](#CHAP-converting-aws-glue-step-api-crawler)

## Etapa 1: criar um banco de dados
<a name="CHAP-converting-aws-glue-step-api-create-db"></a>

A primeira etapa é criar um novo banco de dados em um catálogo de AWS Glue dados usando a [API do AWS SDK](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateDatabase.html). Ao definir uma tabela no catálogo de dados, adicione-a a um banco de dados. Um banco de dados é usado para organizar as tabelas em AWS Glue. 

O exemplo a seguir demonstra o `create_database` método da API Python para. AWS Glue

```
response = client.create_database(
    DatabaseInput={
        'Name': 'database_name’,
        'Description': 'description',
        'LocationUri': 'string',
        'Parameters': {         
            'parameter-name': 'parameter value'
        }
    }
)
```

Se você estiver usando o Amazon Redshift, o nome do banco de dados é formado da maneira a seguir.

```
{redshift_cluster_name}_{redshift_database_name}_{redshift_schema_name}
```

O nome completo do cluster do Amazon Redshift para este exemplo é o seguinte.

```
rsdbb03.apq1mpqso.us-west-2.redshift.amazonaws.com
```

Abaixo, você vê um exemplo de um nome do banco de dados bem estruturado. Nesse caso, `rsdbb03` é o nome, que é a primeira parte do nome completo do endpoint do cluster. O banco de dados é chamado de `dev` e o esquema, de `ora_glue`.

```
rsdbb03_dev_ora_glue
```

## Etapa 2: criar uma conexão
<a name="CHAP-converting-aws-glue-step-api-connection"></a>

Crie uma conexão em um catálogo de dados usando a [API do SDK da AWS](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateConnection.html).

O exemplo a seguir demonstra o uso do [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections.html](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections.html)método da API Python para. AWS Glue

 

```
response = client.create_connection(
    ConnectionInput={
        'Name': 'Redshift_abcde03.aabbcc112233.us-west-2.redshift.amazonaws.com_dev',
        'Description': 'Created from SCT',
        'ConnectionType': 'JDBC',
        'ConnectionProperties': {
            'JDBC_CONNECTION_URL': 'jdbc:redshift://aabbcc03.aabbcc112233.us-west-2.redshift.amazonaws.com:5439/dev',
            'USERNAME': 'user_name',
            'PASSWORD': 'password'
        },
        'PhysicalConnectionRequirements': {
            'AvailabilityZone': 'us-west-2c',
            'SubnetId': 'subnet-a1b23c45',
            'SecurityGroupIdList': [
                'sg-000a2b3c', 'sg-1a230b4c', 'sg-aba12c3d', 'sg-1abb2345'
            ]
        }
    }
)
```

Os parâmetros usados em `create_connection` são os seguintes:
+ `Name` (string UTF-8): obrigatório. Para o Amazon Redshift, o nome da conexão é formado da seguinte forma: `Redshift_<Endpoint-name>_<redshift-database-name>`, por exemplo: ` Redshift_abcde03_dev`
+ `Description` (string UTF-8): sua descrição da conexão.
+ `ConnectionType` (string UTF-8): obrigatório. O tipo de conexão. Atualmente, o JDBC é compatível, mas o SFTP não.
+ `ConnectionProperties` (dict): obrigatório. Uma lista de pares de chave-valor usados como parâmetros para essa conexão, incluindo o URL da conexão JDBC, o nome de usuário e a senha.
+ `PhysicalConnectionRequirements` (dict): requisitos de conexão física, que incluem o seguinte:
  + `SubnetId` (string UTF-8): o ID da sub-rede usada pela conexão.
  + `SecurityGroupIdList` (lista): a lista de IDs de grupos de segurança usada pela conexão.
  + `AvailabilityZone` (string UTF-8): obrigatório. A zona de disponibilidade que contém o endpoint. Esse parâmetro está suspenso.

## Etapa 3: criar um AWS Glue rastreador
<a name="CHAP-converting-aws-glue-step-api-crawler"></a>

Em seguida, você cria um AWS Glue rastreador para preencher o catálogo. AWS Glue Para obter mais informações, consulte [Catalogar tabelas com um crawler](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) no *Guia do desenvolvedor do AWS Glue *.

A primeira etapa para adicionar um crawler é criar um novo banco de dados em um catálogo de dados usando a [API do SDK da AWS](https://docs.aws.amazon.com//glue/latest/webapi/API_CreateCrawler.html). Antes de começar, você deve excluir qualquer versão anterior dele usando a operação `delete_crawler`.

Quando você cria o crawler, algumas considerações se aplicam:
+ Para o nome do crawler, use o formato `<redshift_node_name>_<redshift_database_name>_<redshift_shema_name>`, por exemplo: `abcde03_dev_ora_glue`
+ Use um perfil do IAM que já existe. Para obter mais informações sobre como criar um perfil do IAM, consulte [Criar perfis do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create.html) no *Guia do usuário do IAM*.
+ Use o nome do banco de dados que você criou nas etapas anteriores.
+ Use o parâmetro `ConnectionName`, que é obrigatório.
+ Para o parâmetro `path`, use o caminho para o destino de JDBC, por exemplo: `dev/ora_glue/%`

O exemplo a seguir exclui um crawler existente e cria outro usando a API do AWS Glue em Python. 

```
response = client.delete_crawler(
    Name='crawler_name'
)

response = client.create_crawler(
    Name='crawler_name',
    Role= ‘IAM_role’,
    DatabaseName='database_name’,
    Description='string',
    Targets={
        'S3Targets': [
            {
                'Path': 'string',
                'Exclusions': [
                    'string',
                ]
            },
        ],
        'JdbcTargets': [
            {
                'ConnectionName': ‘ConnectionName’,
                'Path': ‘Include_path’,
                'Exclusions': [
                    'string',
                ]
            },
        ]
    },
    Schedule='string',
    Classifiers=[
        'string',
    ],
    TablePrefix='string',
    SchemaChangePolicy={
        'UpdateBehavior': 'LOG'|'UPDATE_IN_DATABASE',
        'DeleteBehavior': 'LOG'|'DELETE_FROM_DATABASE'|'DEPRECATE_IN_DATABASE'
    },
    Configuration='string'
)
```

Crie e execute um crawler que se conecta a um ou mais armazenamentos de dados, determina as estruturas de dados e grava tabelas no catálogo de dados. Você pode executar o crawler em uma programação, como mostrado a seguir.

```
response = client.start_crawler(
    Name='string'
)
```

Este exemplo usa o Amazon Redshift como destino. Os tipos de dados do Amazon Redshift são AWS Glue mapeados para tipos de dados da seguinte forma após a execução do crawler.


|  |  | 
| --- |--- |
| Tipo de dados do Amazon Redshift | AWS Glue tipo de dados | 
| smallint | smallint | 
| integer | int | 
| bigint | bigint | 
| decimal | decimal(18,0) | 
| decimal(p,s) | decimal(p,s) | 
| real | double | 
| double precision | double | 
| booleano | booleano | 
| char | string | 
| varchar | string | 
| varchar(n) | string | 
| data | data | 
| timestamp | timestamp | 
| timestamptz | timestamp |