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à.

# Automatizza l'inserimento di flussi di dati in un database Snowflake utilizzando Snowflake Snowpipe, Amazon S3, Amazon SNS e Amazon Data Firehose
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose"></a>

*Bikash Chandra Rout, Amazon Web Services*

## Riepilogo
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-summary"></a>

Questo modello descrive come utilizzare i servizi su Amazon Web Services (AWS) Cloud per elaborare un flusso continuo di dati e caricarlo in un database Snowflake. Il modello utilizza Amazon Data Firehose per inviare i dati ad Amazon Simple Storage Service (Amazon S3), Amazon Simple Notification Service (Amazon SNS) per inviare notifiche quando vengono ricevuti nuovi dati e Snowflake Snowpipe per caricare i dati in un database Snowflake.

Seguendo questo schema, puoi avere a disposizione i dati generati continuamente per l'analisi in pochi secondi, evitare più `COPY` comandi manuali e avere il supporto completo per i dati semistrutturati in fase di caricamento.

## Prerequisiti e limitazioni
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-prereqs"></a>

**Prerequisiti**
+ Un attivo Account AWS.
+ Una fonte di dati che invia continuamente dati a un flusso di distribuzione Firehose.
+ Un bucket S3 esistente che riceve i dati dal flusso di distribuzione di Firehose.
+ Un account Snowflake attivo.

**Limitazioni**
+ Snowflake Snowpipe non si collega direttamente a Firehose.

## Architecture
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-architecture"></a>

![\[I dati acquisiti da Firehose vengono trasferiti ad Amazon S3, Amazon SNS, Snowflake Snowpipe e Snowflake DB.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/0c6f473b-973f-4229-a12e-ef697ae9b299/images/0adee3fb-1b90-4f7d-b2d0-b3b958f62c75.png)


**Stack tecnologico**
+ Amazon Data Firehose
+ Amazon SNS
+ Simple Storage Service (Amazon S3)
+ Snowflake Snowpipe
+ Banca dati Snowflake

## Tools (Strumenti)
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-tools"></a>
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) è un servizio completamente gestito per la distribuzione di dati di streaming in tempo reale a destinazioni come Amazon S3, Amazon Redshift, OpenSearch Amazon Service, Splunk e qualsiasi endpoint HTTP o endpoint HTTP personalizzato di proprietà di provider di servizi terzi supportati.
+ [Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html)) è uno storage per Internet.
+ [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) coordina e gestisce la consegna o l'invio di messaggi agli endpoint o ai clienti abbonati.
+ [Snowflake](https://www.snowflake.com/) — Snowflake è un data warehouse analitico fornito come (SaaS). Software-as-a-Service
+ [Snowflake Snowpipe: Snowpipe](https://docs.snowflake.com/en/user-guide/data-load-snowpipe-intro.html) carica i dati dai file non appena sono disponibili in una fase Snowflake.

## Epiche
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-epics"></a>

### Configura uno Snowflake Snowpipe
<a name="set-up-a-snowflake-snowpipe"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un file CSV in Snowflake. | Accedi a Snowflake ed esegui il `CREATE FILE FORMAT` comando per creare un file CSV con un delimitatore di campo specificato. [Per ulteriori informazioni su questo e altri comandi Snowflake, consulta la sezione Informazioni aggiuntive.](#automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-additional) | Developer | 
| Crea uno stage Snowflake esterno. | Eseguite il `CREATE STAGE` comando per creare uno stage Snowflake esterno che faccia riferimento al file CSV creato in precedenza. Importante: avrai bisogno dell'URL del bucket S3, della tua chiave di accesso e della tua chiave di AWS accesso segreta. AWS Esegui il `SHOW STAGES` comando per verificare che lo stage Snowflake sia stato creato. | Developer  | 
| Create la tabella di destinazione Snowflake. | Esegui il `CREATE TABLE` comando per creare la tabella Snowflake. | Developer | 
| Crea una pipa. | Esegui il `CREATE PIPE` comando; assicurati che `auto_ingest=true` sia nel comando. Eseguite il `SHOW PIPES` comando per verificare che la pipe sia stata creata. Copia e salva il valore `notification_channel` della colonna. Questo valore verrà utilizzato per configurare le notifiche degli eventi di Amazon S3. | Developer | 

### Configura il bucket S3
<a name="configure-the-s3-bucket"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea una politica del ciclo di vita di 30 giorni per il bucket S3. | Accedi Console di gestione AWS e apri la console Amazon S3. Scegliete il bucket S3 che contiene i dati di Firehose. **Quindi scegli la scheda **Gestione** nel bucket S3 e scegli Aggiungi regola del ciclo di vita.** Inserisci un nome per la regola nella finestra di dialogo delle regole del **ciclo di vita e configura una regola del ciclo** di vita di 30 giorni per il tuo bucket. [Per informazioni su questa e altre storie, consulta la sezione Risorse correlate.](#automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-resources) | Amministratore di sistema, sviluppatore | 
| Crea una policy IAM per il bucket S3. | **Apri la console AWS Identity and Access Management (IAM) e scegli Policies.** Scegli **Create policy (Crea policy)**, quindi scegli la scheda **JSON**. Copia e incolla la policy dalla sezione [Informazioni aggiuntive](#automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-additional) nel campo JSON. Questa politica concederà `PutObject` e `DeleteObject` autorizzazioni, nonché `GetObject``GetObjectVersion`, e `ListBucket` autorizzazioni. Scegli **Rivedi politica**, inserisci un nome di politica, quindi scegli **Crea** politica. | Amministratore di sistema, sviluppatore | 
| Assegna la policy a un ruolo IAM. | Apri la console IAM, scegli **Ruoli**, quindi scegli **Crea ruolo**. Scegli **un altro account AWS** come entità affidabile. Inserisci il tuo Account AWS ID e scegli **Richiedi un ID esterno**. Inserisci un ID segnaposto che potrai modificare in seguito. Scegli **Avanti** e assegna la policy IAM che hai creato in precedenza. Quindi crea il ruolo IAM. | Amministratore di sistema, sviluppatore | 
| Copia l'Amazon Resource Name (ARN) per il ruolo IAM. | Apri la console IAM e scegli **Ruoli**. Scegli il ruolo IAM che hai creato in precedenza, quindi copia e archivia l'**ARN del ruolo**. | Amministratore di sistema, sviluppatore | 

### Configura un'integrazione dello storage in Snowflake
<a name="set-up-a-storage-integration-in-snowflake"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un'integrazione di archiviazione in Snowflake. | Accedi a Snowflake ed esegui il comando. `CREATE STORAGE INTEGRATION` Ciò modificherà la relazione di fiducia, concederà l'accesso a Snowflake e fornirà l'ID esterno per il tuo stage Snowflake. | Amministratore di sistema, sviluppatore | 
| Recupera il ruolo IAM per il tuo account Snowflake. | Esegui il `DESC INTEGRATION` comando per recuperare l'ARN per il ruolo IAM.`<integration_ name>`è il nome dell'integrazione di storage Snowflake creata in precedenza. | Amministratore di sistema, sviluppatore | 
| Registra due valori di colonna. | Copia e salva i valori per le `storage_aws_external_id` colonne `storage_aws_iam_user_arn` and. | Amministratore di sistema, sviluppatore | 

### Consenti a Snowflake Snowpipe di accedere al bucket S3
<a name="allow-snowflake-snowpipe-to-access-the-s3-bucket"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Modifica la politica dei ruoli IAM. | Apri la console IAM e scegli **Ruoli**. Scegli il ruolo IAM che hai creato in precedenza e scegli la scheda **Relazioni di fiducia**. Seleziona **Modifica relazione di attendibilità**. `snowflake_external_id`Sostituiscilo con il `storage_aws_external_id` valore che hai copiato in precedenza. Sostituisci `snowflake_user_arn` con il `storage_aws_iam_user_arn` valore che hai copiato in precedenza. Quindi scegli **Aggiorna politica di fiducia**. | Amministratore di sistema, sviluppatore | 

### Attiva e configura le notifiche SNS per il bucket S3
<a name="turn-on-and-configure-sns-notifications-for-the-s3-bucket"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Attiva le notifiche degli eventi per il bucket S3. | Apri la console Amazon S3 e scegli il tuo bucket. **Scegli **Proprietà** e, in **Impostazioni avanzate**, scegli Eventi.** Scegli **Aggiungi notifica** e inserisci un nome per questo evento. Se non inserisci un nome, verrà utilizzato un identificatore univoco globale (GUID). | Amministratore di sistema, sviluppatore | 
| Configura le notifiche Amazon SNS per il bucket S3. | **In **Eventi**, scegli **ObjectCreate (Tutti)**, quindi scegli **SQS Queue nell'elenco a discesa Invia** a.** Nell'elenco **SNS**, scegli **Aggiungi ARN della coda SQS** e incolla `notification_channel` il valore che hai copiato in precedenza. Quindi scegli **Save** (Salva). | Amministratore di sistema, sviluppatore | 
| Sottoscrivi la coda Snowflake SQS all'argomento SNS. | Sottoscrivi la coda Snowflake SQS all'argomento SNS che hai creato. [Per informazioni su questo passaggio, consulta la sezione Risorse correlate.](#automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-resources) | Amministratore di sistema, sviluppatore | 

### Verifica l'integrazione con Snowflake Stage
<a name="check-the-snowflake-stage-integration"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Controlla e prova Snowpipe. | Accedi a Snowflake e apri il livello Snowflake. Trascina i file nel tuo bucket S3 e controlla se la tabella Snowflake li carica. Amazon S3 invierà notifiche SNS a Snowpipe quando vengono visualizzati nuovi oggetti nel bucket S3. | Amministratore di sistema, sviluppatore | 

## Risorse correlate
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-resources"></a>
+ [Gestione del ciclo di vita dello storage](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html)
+ [Sottoscrivi la coda SQS di Snowflake all'argomento Amazon SNS](https://docs.snowflake.com/en/user-guide/data-load-snowpipe-auto-s3.html#prerequisite-create-an-amazon-sns-topic-and-subscription)

## Informazioni aggiuntive
<a name="automate-data-stream-ingestion-into-a-snowflake-database-by-using-snowflake-snowpipe-amazon-s3-amazon-sns-and-amazon-data-firehose-additional"></a>

**Crea un formato di file:**

```
CREATE FILE FORMAT <name>
TYPE = 'CSV'
FIELD_DELIMITER = '|'
SKIP_HEADER = 1;
```

**Crea una fase esterna:**

```
externalStageParams (for Amazon S3) ::=
  URL = 's3://[//]'

  [ { STORAGE_INTEGRATION =  } | { CREDENTIALS = ( {  { AWS_KEY_ID = `` AWS_SECRET_KEY = `` [ AWS_TOKEN = `` ] } | AWS_ROLE = ``  } ) ) }` ]
  [ ENCRYPTION = ( [ TYPE = 'AWS_CSE' ] [ MASTER_KEY = '' ] |
                   [ TYPE = 'AWS_SSE_S3' ] |
                   [ TYPE = 'AWS_SSE_KMS' [ KMS_KEY_ID = '' ] |
                   [ TYPE = NONE ] )
```

**Crea una tabella:**

```
CREATE [ OR REPLACE ] [ { [ LOCAL | GLOBAL ] TEMP[ORARY] | VOLATILE } | TRANSIENT ] TABLE [ IF NOT EXISTS ]
  <table_name>
    ( <col_name> <col_type> [ { DEFAULT <expr>
                               | { AUTOINCREMENT | IDENTITY } [ ( <start_num> , <step_num> ) | START <num> INCREMENT <num> ] } ]
                                /* AUTOINCREMENT / IDENTITY supported only for numeric data types (NUMBER, INT, etc.) */
                            [ inlineConstraint ]
      [ , <col_name> <col_type> ... ]
      [ , outoflineConstraint ]
      [ , ... ] )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ STAGE_FILE_FORMAT = ( { FORMAT_NAME = '<file_format_name>'
                           | TYPE = { CSV | JSON | AVRO | ORC | PARQUET | XML } [ formatTypeOptions ] } ) ]
  [ STAGE_COPY_OPTIONS = ( copyOptions ) ]
  [ DATA_RETENTION_TIME_IN_DAYS = <num> ]
  [ COPY GRANTS ]
  [ COMMENT = '<string_literal>' ]
```

**Mostra fasi:**

```
SHOW STAGES;
```

**Crea una pipa:**

```
CREATE [ OR REPLACE ] PIPE [ IF NOT EXISTS ] 
  [ AUTO_INGEST = [ TRUE | FALSE ] ]
  [ AWS_SNS_TOPIC =  ]
  [ INTEGRATION = '' ]
  [ COMMENT = '' ]
  AS
```

**Mostra tubi:**

```
SHOW PIPES [ LIKE '<pattern>' ]           
           [ IN { ACCOUNT | [ DATABASE ] <db_name> | [ SCHEMA ] <schema_name> } ]
```

**Crea un'integrazione di archiviazione:**

```
CREATE STORAGE INTEGRATION <integration_name>
  TYPE = EXTERNAL_STAGE
  STORAGE_PROVIDER = S3
  ENABLED = TRUE
  STORAGE_AWS_ROLE_ARN = '<iam_role>'
  STORAGE_ALLOWED_LOCATIONS = ('s3://<bucket>/<path>/', 's3://<bucket>/<path>/')
  [ STORAGE_BLOCKED_LOCATIONS = ('s3://<bucket>/<path>/', 's3://<bucket>/<path>/') ]
```

Esempio:

```
create storage integration s3_int
  type = external_stage
  storage_provider = s3
  enabled = true
  storage_aws_role_arn = 'arn:aws:iam::001234567890:role/myrole'
  storage_allowed_locations = ('s3://amzn-s3-demo-bucket1/mypath1/', 's3://amzn-s3-demo-bucket2/mypath2/')
  storage_blocked_locations = ('s3://amzn-s3-demo-bucket1/mypath1/sensitivedata/', 's3://amzn-s3-demo-bucket2/mypath2/sensitivedata/');
```

Per ulteriori informazioni su questo passaggio, consulta [Configurazione di un'integrazione di storage Snowflake per accedere ad Amazon S3 dalla documentazione di Snowflake](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html).

**Descrivi un'integrazione:**

```
DESC INTEGRATION <integration_name>;
```

**Politica sui bucket S3:**

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
              "s3:PutObject",
              "s3:GetObject",
              "s3:GetObjectVersion",
              "s3:DeleteObject",
              "s3:DeleteObjectVersion"
            ],
            "Resource": "arn:aws:s3::://*"
        },
        {
            "Effect": "Allow",
            "Action": "s3:ListBucket",
            "Resource": "arn:aws:s3:::",
            "Condition": {
                "StringLike": {
                    "s3:prefix": [
                        "/*"
                    ]
                }
            }
        }
    ]
}
```