Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Conversione dei processi ETL in in AWS Glue AWS Schema Conversion Tool
<a name="CHAP-converting-aws-glue-api-process"></a>

Nelle sezioni seguenti, puoi trovare una descrizione di una conversione che chiama le operazioni AWS Glue API in Python. *Per ulteriori informazioni, consulta [Program AWS Glue ETL scripts in Python](https://docs.aws.amazon.com//glue/latest/dg/aws-glue-programming-python.html) nella Developer Guide. AWS Glue *

**Topics**
+ [Fase 1: crea un database](#CHAP-converting-aws-glue-step-api-create-db)
+ [Fase 2: creare una connessione](#CHAP-converting-aws-glue-step-api-connection)
+ [Fase 3: Creare un crawler AWS Glue](#CHAP-converting-aws-glue-step-api-crawler)

## Fase 1: crea un database
<a name="CHAP-converting-aws-glue-step-api-create-db"></a>

[Il primo passaggio consiste nel creare un nuovo database in un catalogo AWS Glue dati utilizzando l'AWS API SDK.](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateDatabase.html) Quando una tabella viene definita nel catalogo dati, viene aggiunta a un database. Un database viene utilizzato per organizzare le tabelle in AWS Glue. 

L'esempio seguente mostra il `create_database` metodo dell'API Python for. AWS Glue

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

Se utilizzi Amazon Redshift, il nome del database è formato come segue.

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

Il nome completo del cluster Amazon Redshift per questo esempio è il seguente.

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

L’esempio seguente mostra un nome di database valido. In questo caso, `rsdbb03` è il nome, che è la prima parte del nome completo dell’endpoint del cluster. Il nome del database è `dev` e lo schema è `ora_glue`.

```
rsdbb03_dev_ora_glue
```

## Fase 2: creare una connessione
<a name="CHAP-converting-aws-glue-step-api-connection"></a>

Crea una nuova connessione in un catalogo dati utilizzando l'[API AWS SDK](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateConnection.html).

L'esempio seguente dimostra l'utilizzo del [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)metodo dell'API Python per. 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'
            ]
        }
    }
)
```

I parametri utilizzati in `create_connection` sono i seguenti:
+ `Name`(stringa UTF-8): obbligatorio. Per Amazon Redshift, il nome della connessione è formato come segue:`Redshift_<Endpoint-name>_<redshift-database-name>`, ad esempio: ` Redshift_abcde03_dev`
+ `Description`(stringa UTF-8): la tua descrizione della connessione.
+ `ConnectionType`(stringa UTF-8) — Obbligatorio. Il tipo di connessione. Al momento è supportata solo JDBC; SFTP non è supportata.
+ `ConnectionProperties`(dict) — Obbligatorio. Un elenco di coppie chiave-valore utilizzate come parametri per questa connessione, inclusi l'URL della connessione JDBC, il nome utente e la password.
+ `PhysicalConnectionRequirements`(dict) — Requisiti di connessione fisica, che includono quanto segue:
  + `SubnetId`(stringa UTF-8) — L'ID della sottorete utilizzata dalla connessione.
  + `SecurityGroupIdList`(elenco) — L'elenco degli ID del gruppo di sicurezza utilizzato dalla connessione.
  + `AvailabilityZone`(stringa UTF-8) — Obbligatoria. La zona di disponibilità che contiene l'endpoint. Questo parametro è obsoleto.

## Fase 3: Creare un crawler AWS Glue
<a name="CHAP-converting-aws-glue-step-api-crawler"></a>

Successivamente, create un AWS Glue crawler per popolare il catalogo. AWS Glue *Per ulteriori informazioni, consulta [Catalogare le tabelle con un crawler](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) nella Guida per gli sviluppatori.AWS Glue *

[Il primo passaggio per aggiungere un crawler consiste nel creare un nuovo database in un Data Catalog utilizzando l'API SDK.AWS](https://docs.aws.amazon.com//glue/latest/webapi/API_CreateCrawler.html) Prima di iniziare, assicurati di eliminarne prima qualsiasi versione precedente utilizzando l'operazione. `delete_crawler`

Durante la creazione di un crawler è necessario tenere conto di alcuni aspetti:
+ Per il nome del crawler è necessario utilizzare il formato `<redshift_node_name>_<redshift_database_name>_<redshift_shema_name>`, ad esempio: `abcde03_dev_ora_glue`
+ È necessario utilizzare un ruolo IAM già esistente. Per ulteriori informazioni sulla creazione di ruoli IAM, consulta [Creating IAM roles](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create.html) nella *IAM User Guide.*
+ È necessario utilizzare il nome del database creato nelle fasi precedenti.
+ Il parametro `ConnectionName` va utilizzato perché è obbligatorio.
+ Per il parametro `path`, occorre utilizzare il percorso della destinazione JDBC, ad esempio: `dev/ora_glue/%`

L'esempio seguente elimina un crawler esistente, quindi ne crea uno nuovo, utilizzando l'API Python per AWS Glue. 

```
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'
)
```

Crea e quindi esegui un crawler che si collega a uno o più datastore, determina le strutture dei dati e scrive tabelle nel catalogo dati. È possibile eseguire il crawler secondo un programma, come illustrato di seguito.

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

Questo esempio utilizza Amazon Redshift come destinazione. I tipi di dati di Amazon Redshift vengono AWS Glue mappati ai tipi di dati nel modo seguente dopo l'esecuzione del crawler.


|  |  | 
| --- |--- |
| Tipo di dati Amazon Redshift | AWS Glue tipo di dati | 
| smallint | smallint | 
| integer | int | 
| bigint | bigint | 
| decimal | decimal(18,0) | 
| decimal(p,s) | decimal(p,s) | 
| real | double | 
| double precision | double | 
| Booleano | Booleano | 
| char | Stringa | 
| varchar | Stringa | 
| varchar(n) | Stringa | 
| date | date | 
| timestamp | timestamp | 
| timestamptz | timestamp |