Per funzionalità simili a Amazon Timestream for, prendi in considerazione Amazon Timestream LiveAnalytics per InfluxDB. Offre un'acquisizione semplificata dei dati e tempi di risposta alle query di una sola cifra di millisecondi per analisi in tempo reale. [Scopri](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html) di più qui. 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à. # Utilizzo di UNLOAD per esportare i risultati delle query su S3 da Timestream per LiveAnalytics Amazon Timestream LiveAnalytics per ora ti consente di esportare i risultati delle tue query su Amazon S3 in modo economico e sicuro utilizzando l'istruzione. `UNLOAD` Utilizzando l'`UNLOAD`istruzione, ora puoi esportare i dati delle serie temporali in bucket S3 selezionati in formato Apache Parquet o Comma Separated Values (CSV), il che offre la flessibilità necessaria per archiviare, combinare e analizzare i dati delle serie temporali con altri servizi. L'`UNLOAD`istruzione consente di esportare i dati in modo compresso, il che riduce i dati trasferiti e lo spazio di archiviazione richiesto. `UNLOAD`supporta anche il partizionamento basato su attributi selezionati durante l'esportazione dei dati, migliorando le prestazioni e riducendo i tempi di elaborazione dei servizi a valle che accedono ai dati. Inoltre, puoi utilizzare chiavi gestite Amazon S3 (SSE-S3) o AWS chiavi gestite da Amazon S3 (AWS SSE-KMS) per crittografare i dati esportati. ## Vantaggi di UNLOAD di Timestream per LiveAnalytics I vantaggi principali dell'utilizzo della `UNLOAD` dichiarazione sono i seguenti. + **Facilità operativa**: con l'`UNLOAD`istruzione, è possibile esportare gigabyte di dati in un'unica richiesta di query in formato Apache Parquet o CSV, offrendo la flessibilità necessaria per selezionare il formato più adatto alle esigenze di elaborazione a valle e semplificando la creazione di data lake. + **Sicuro ed economico**: `UNLOAD` statement offre la possibilità di esportare i dati in un bucket S3 in modo compresso e di crittografare (SSE-KMS o SSE\$1S3) i dati utilizzando chiavi gestite dal cliente, riducendo i costi di archiviazione dei dati e proteggendo dall'accesso non autorizzato. + **Prestazioni**: utilizzando l'`UNLOAD`istruzione, puoi partizionare i dati durante l'esportazione in un bucket S3. Il partizionamento dei dati consente ai servizi a valle di elaborare i dati in parallelo, riducendone i tempi di elaborazione. Inoltre, i servizi a valle possono elaborare solo i dati di cui hanno bisogno, riducendo le risorse di elaborazione necessarie e quindi i costi associati. ## Casi d'uso di UNLOAD from Timestream per LiveAnalytics Puoi utilizzare l'`UNLOAD`istruzione per scrivere dati nel tuo bucket S3 nei seguenti modi. + **Crea un data warehouse**: puoi esportare gigabyte di risultati delle query nel bucket S3 e aggiungere più facilmente dati di serie temporali al tuo data lake. Puoi utilizzare servizi come Amazon Athena e Amazon Redshift per combinare i dati delle tue serie temporali con altri dati pertinenti per ricavare informazioni aziendali complesse. + **Crea pipeline di dati AI e ML**: la `UNLOAD` dichiarazione ti consente di creare facilmente pipeline di dati per i tuoi modelli di machine learning che accedono ai dati delle serie temporali, semplificando l'utilizzo dei dati delle serie temporali con servizi come Amazon e SageMaker Amazon EMR. + **Semplifica l'elaborazione ETL**: l'esportazione dei dati in bucket S3 può semplificare il processo di esecuzione delle operazioni di estrazione, trasformazione, caricamento (ETL) sui dati, consentendoti di utilizzare senza problemi strumenti o servizi di terze parti AWS come AWS Glue per elaborare e trasformare i dati. # SCARICA I CONCETTI ## Sintassi ``` UNLOAD (SELECT statement) TO 's3://bucket-name/folder' WITH ( option = expression [, ...] ) ``` dov'è `option` ``` { partitioned_by = ARRAY[ col_name[,…] ] | format = [ '{ CSV | PARQUET }' ] | compression = [ '{ GZIP | NONE }' ] | encryption = [ '{ SSE_KMS | SSE_S3 }' ] | kms_key = '' | field_delimiter ='' | escaped_by = '' | include_header = ['{true, false}'] | max_file_size = '' | } ``` ## Parameters dichiarazione SELECT L'istruzione di query utilizzata per selezionare e recuperare i dati da uno o più Timestream per le tabelle. LiveAnalytics ``` (SELECT column 1, column 2, column 3 from database.table where measure_name = "ABC" and timestamp between ago (1d) and now() ) ``` Clausola TO ``` TO 's3://bucket-name/folder' ``` or ``` TO 's3://access-point-alias/folder' ``` La `TO` clausola dell'`UNLOAD`istruzione specifica la destinazione dell'output dei risultati della query. È necessario fornire il percorso completo, incluso il nome del bucket Amazon S3 o Amazon S3 con access-point-alias posizione della cartella su Amazon S3 dove Timestream for scrive gli oggetti del file di output. LiveAnalytics Il bucket S3 deve appartenere allo stesso account e nella stessa regione. Oltre al set di risultati della query, Timestream for LiveAnalytics scrive i file manifest e di metadati nella cartella di destinazione specificata. Clausola PARTITIONED\$1BY ``` partitioned_by = ARRAY [col_name[,…] , (default: none) ``` La `partitioned_by` clausola viene utilizzata nelle query per raggruppare e analizzare i dati a livello granulare. Quando esporti i risultati della query nel bucket S3, puoi scegliere di partizionare i dati in base a una o più colonne nella query di selezione. Durante il partizionamento dei dati, i dati esportati vengono suddivisi in sottoinsiemi in base alla colonna della partizione e ogni sottoinsieme viene archiviato in una cartella separata. All'interno della cartella dei risultati che contiene i dati esportati, viene creata automaticamente una sottocartella. `folder/results/partition column = partition value/` Tuttavia, tieni presente che le colonne partizionate non sono incluse nel file di output. `partitioned_by`non è una clausola obbligatoria nella sintassi. Se si sceglie di esportare i dati senza alcun partizionamento, è possibile escludere la clausola nella sintassi. **Example** Supponendo che tu stia monitorando i dati clickstream del tuo sito Web e che tu abbia 5 canali di traffico, vale a dire,, e. `direct` `Social Media` `Organic Search` `Other` `Referral` Quando si esportano i dati, è possibile scegliere di partizionarli utilizzando la colonna. `Channel` All'interno della tua cartella dati`s3://bucketname/results`, avrai cinque cartelle ciascuna con il rispettivo nome del canale, ad esempio, `s3://bucketname/results/channel=Social Media/.` all'interno di questa cartella troverai i dati di tutti i clienti che sono arrivati sul tuo sito web attraverso il `Social Media` canale. Allo stesso modo, avrai altre cartelle per i canali rimanenti. Dati esportati partizionati per colonna Channel ![\[Folder structure showing channels: Direct, Organic search, Other, Referral, and Social media.\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/images/unload-results.png) FORMAT ``` format = [ '{ CSV | PARQUET }' , default: CSV ``` Le parole chiave per specificare il formato dei risultati della query scritti nel bucket S3. È possibile esportare i dati come valore separato da virgole (CSV) utilizzando una virgola (,) come delimitatore predefinito o nel formato Apache Parquet, un efficiente formato di archiviazione a colonne aperto per l'analisi. COMPRESSIONE ``` compression = [ '{ GZIP | NONE }' ], default: GZIP ``` È possibile comprimere i dati esportati utilizzando l'algoritmo di compressione GZIP o decomprimerli specificando l'opzione. `NONE` ENCRYPTION ``` encryption = [ '{ SSE_KMS | SSE_S3 }' ], default: SSE_S3 ``` I file di output su Amazon S3 vengono crittografati utilizzando l'opzione di crittografia selezionata. Oltre ai dati, anche i file manifest e i file di metadati vengono crittografati in base all'opzione di crittografia selezionata. Attualmente supportiamo la crittografia SSE\$1S3 e SSE\$1KMS. SSE\$1S3 è una crittografia lato server con Amazon S3 che crittografa i dati utilizzando la crittografia AES (Advanced Encryption Standard) a 256 bit. SSE\$1KMS è una crittografia lato server per crittografare i dati utilizzando chiavi gestite dal cliente. KMS\$1KEY ``` kms_key = '' ``` KMS Key è una chiave definita dal cliente per crittografare i risultati delle query esportate. KMS Key è gestita in modo sicuro da AWS Key Management Service (AWS KMS) e utilizzata per crittografare i file di dati su Amazon S3. FIELD\$1DELIMITER ``` field_delimiter ='' , default: (,) ``` Quando si esportano i dati in formato CSV, questo campo specifica un singolo carattere ASCII utilizzato per separare i campi nel file di output, ad esempio il carattere pipe (\$1), la virgola (,) o il tab (/t). Il delimitatore predefinito per i file CSV è una virgola. Se un valore nei dati contiene il delimitatore scelto, il delimitatore verrà citato tra virgolette. Ad esempio, se il valore dei dati contiene`Time,stream`, questo valore verrà citato come nei dati esportati. `"Time,stream"` Il carattere di virgoletta usato da Timestream per sono le LiveAnalytics virgolette doppie («). Evita di specificare il carattere di ritorno al carrello (ASCII 13`0D`, hex, text '\$1 r') o il carattere di interruzione di riga (ASCII 10, hex 0A, text'\$1n') come `FIELD_DELIMITER` se desideri includere le intestazioni nel CSV, poiché ciò impedirà a molti parser di analizzare correttamente le intestazioni nell'output CSV risultante. ESCAPED\$1BY ``` escaped_by = '', default: (\) ``` Quando si esportano i dati in formato CSV, questo campo specifica il carattere che deve essere trattato come carattere di escape nel file di dati scritto nel bucket S3. L'escape avviene nei seguenti scenari: 1. Se il valore stesso contiene il carattere di virgoletta («), verrà eliminato utilizzando un carattere di escape. Ad esempio, se il valore è`Time"stream`, dove (\$1) è il carattere di escape configurato, allora verrà escluso come. `Time\"stream` 1. Se il valore contiene il carattere di escape configurato, verrà eliminato. Ad esempio, se il valore è`Time\stream`, allora verrà scappato come. `Time\\stream` Se l'output esportato contiene tipi di dati complessi come Arrays, Rows o Timeseries, verrà serializzato come stringa JSON. Di seguito è riportato un esempio. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/export-unload-concepts.html) INCLUDE\$1HEADER ``` include_header = 'true' , default: 'false' ``` Quando si esportano i dati in formato CSV, questo campo consente di includere i nomi delle colonne come prima riga dei file di dati CSV esportati. I valori accettati sono «true» e «false» e il valore predefinito è «false». Le opzioni di trasformazione del testo come `escaped_by` e `field_delimiter` si applicano anche alle intestazioni. Quando si includono le intestazioni, è importante non selezionare un carattere di ritorno (ASCII 13, hex 0D, testo '\$1 r') o un carattere di interruzione di riga (ASCII 10, hex 0A, text'\$1n') come carattere`FIELD_DELIMITER`, poiché ciò impedirà a molti parser di analizzare correttamente le intestazioni nell'output CSV risultante. MAX\$1FILE\$1SIZE ``` max_file_size = 'X[MB|GB]' , default: '78GB' ``` Questo campo specifica la dimensione massima dei file che l'`UNLOAD`istruzione crea in Amazon S3. L'`UNLOAD`istruzione può creare più file, ma la dimensione massima di ogni file scritto in Amazon S3 sarà approssimativamente quella specificata in questo campo. Il valore del campo deve essere compreso tra 16 MB e 78 GB, inclusi. È possibile specificarlo in numeri interi come `12GB` o in decimali come o. `0.5GB` `24.7MB` Il valore predefinito è 78 GB. La dimensione effettiva del file è approssimativa al momento della scrittura del file, pertanto la dimensione massima effettiva potrebbe non essere esattamente uguale al numero specificato. ## Cosa viene scritto nel mio bucket S3? Per ogni query UNLOAD eseguita correttamente, Timestream for LiveAnalytics scrive i risultati della query, il file di metadati e il file manifest nel bucket S3. Se hai partizionato i dati, hai tutte le cartelle delle partizioni nella cartella dei risultati. Il file manifesto contiene un elenco dei file che sono stati scritti dal comando UNLOAD. Il file di metadati contiene informazioni che descrivono le caratteristiche, le proprietà e gli attributi dei dati scritti. ## Qual è il nome del file esportato? Il nome del file esportato contiene due componenti, il primo componente è il QueryID e il secondo è un identificatore univoco. File CSV ``` S3://bucket_name/results/_.csv S3://bucket_name/results/=/_.csv ``` File CSV compresso ``` S3://bucket_name/results/=/_.gz ``` File Parquet ``` S3://bucket_name/results/=/_.parquet ``` Metadati e file manifesto ``` S3://bucket_name/__manifest.json S3://bucket_name/__metadata.json ``` Poiché i dati in formato CSV vengono archiviati a livello di file, quando si comprimono i dati durante l'esportazione in S3, il file avrà un'estensione «.gz». Tuttavia, i dati in Parquet vengono compressi a livello di colonna, quindi anche quando si comprimono i dati durante l'esportazione, il file avrà comunque l'estensione.parquet. ## Quali informazioni contiene ogni file? ### File manifest Il file manifest fornisce informazioni sull'elenco dei file che vengono esportati con l'esecuzione UNLOAD. Il file manifest è disponibile nel bucket S3 fornito con un nome di file:. `s3:///__manifest.json` Il file manifest conterrà l'URL dei file nella cartella dei risultati, il numero di record e le dimensioni dei rispettivi file, e i metadati della query (ovvero i byte totali e le righe totali esportati in S3 per la query). ``` { "result_files": [ { "url":"s3://my_timestream_unloads/ec2_metrics/AEDAGANLHLBH4OLISD3CVOZZRWPX5GV2XCXRBKCVD554N6GWPWWXBP7LSG74V2Q_1448466917_szCL4YgVYzGXj2lS.gz", "file_metadata": { "content_length_in_bytes": 32295, "row_count": 10 } }, { "url":"s3://my_timestream_unloads/ec2_metrics/AEDAGANLHLBH4OLISD3CVOZZRWPX5GV2XCXRBKCVD554N6GWPWWXBP7LSG74V2Q_1448466917_szCL4YgVYzGXj2lS.gz", "file_metadata": { "content_length_in_bytes": 62295, "row_count": 20 } }, ], "query_metadata": { "content_length_in_bytes": 94590, "total_row_count": 30, "result_format": "CSV", "result_version": "Amazon Timestream version 1.0.0" }, "author": { "name": "Amazon Timestream", "manifest_file_version": "1.0" } } ``` ### Metadati Il file di metadati fornisce informazioni aggiuntive sul set di dati come il nome della colonna, il tipo di colonna e lo schema. Il file di metadati è disponibile nel bucket S3 fornito con un nome di file: S3: //bucket\$1name/ \$1 \$1metadata.json Di seguito è riportato un esempio di file di metadati. ``` { "ColumnInfo": [ { "Name": "hostname", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "region", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "measure_name", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "cpu_utilization", "Type": { "TimeSeriesMeasureValueColumnInfo": { "Type": { "ScalarType": "DOUBLE" } } } } ], "Author": { "Name": "Amazon Timestream", "MetadataFileVersion": "1.0" } } ``` Le informazioni sulle colonne condivise nel file di metadati hanno la stessa struttura di quelle `ColumnInfo` inviate nella risposta dell'API Query per le `SELECT` query. ### Risultati La cartella dei risultati contiene i dati esportati in formato Apache Parquet o CSV. ## Esempio Quando invii una richiesta come quella riportata di seguito tramite l'API `UNLOAD` Query, ``` UNLOAD(SELECT user_id, ip_address, event, session_id, measure_name, time, query, quantity, product_id, channel FROM sample_clickstream.sample_shopping WHERE time BETWEEN ago(2d) AND now()) TO 's3://my_timestream_unloads/withoutpartition/' WITH ( format='CSV', compression='GZIP') ``` `UNLOAD`la risposta alla query avrà 1 riga \$1 3 colonne. Queste 3 colonne sono: + righe di tipo BIGINT, che indicano il numero di righe esportate + MetadataFile di tipo VARCHAR, che è l'URI S3 del file di metadati esportato + manifestFile di tipo VARCHAR, che è l'URI S3 del file manifesto esportato Riceverai la seguente risposta dall'API Query: ``` { "Rows": [ { "Data": [ { "ScalarValue": "20" # No of rows in output across all files }, { "ScalarValue": "s3://my_timestream_unloads/withoutpartition/AEDAAANGH3D7FYHOBQGQQMEAISCJ45B42OWWJMOT4N6RRJICZUA7R25VYVOHJIY__metadata.json" #Metadata file }, { "ScalarValue": "s3://my_timestream_unloads/withoutpartition/AEDAAANGH3D7FYHOBQGQQMEAISCJ45B42OWWJMOT4N6RRJICZUA7R25VYVOHJIY__manifest.json" #Manifest file } ] } ], "ColumnInfo": [ { "Name": "rows", "Type": { "ScalarType": "BIGINT" } }, { "Name": "metadataFile", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "manifestFile", "Type": { "ScalarType": "VARCHAR" } } ], "QueryId": "AEDAAANGH3D7FYHOBQGQQMEAISCJ45B42OWWJMOT4N6RRJICZUA7R25VYVOHJIY", "QueryStatus": { "ProgressPercentage": 100.0, "CumulativeBytesScanned": 1000, "CumulativeBytesMetered": 10000000 } } ``` ## Tipi di dati L'`UNLOAD`istruzione supporta tutti i tipi di dati del linguaggio di query LiveAnalytics di Timestream for descritto in [Tipi di dati supportati](supported-data-types.md) tranne `time` e. `unknown` # Prerequisiti per UNLOAD from Timestream per LiveAnalytics Di seguito sono riportati i prerequisiti per la scrittura di dati su S3 utilizzando from Timestream for. `UNLOAD` LiveAnalytics + È necessario disporre dell'autorizzazione a leggere i dati dal Timestream per le LiveAnalytics tabelle da utilizzare in un comando. `UNLOAD` + Devi avere un bucket Amazon S3 nella stessa AWS regione del tuo Timestream per le risorse. LiveAnalytics + Per il bucket S3 selezionato, assicurati che la [policy del bucket S3 disponga anche delle autorizzazioni per consentire a Timestream](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html) di esportare i dati. LiveAnalytics + Le credenziali utilizzate per eseguire la `UNLOAD` query devono disporre delle autorizzazioni AWS Identity and Access Management (IAM) necessarie che consentano a Timestream di scrivere i dati LiveAnalytics su S3. Un esempio di politica potrebbe essere il seguente: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "timestream:Select", "timestream:ListMeasures", "timestream:WriteRecords", "timestream:Unload" ], "Resource": "arn:aws:timestream:us-east-2:111122223333:database/database_name/table/table_name" }, { "Effect": "Allow", "Action": [ "s3:GetBucketAcl", "s3:PutObject", "s3:GetObject", "s3:AbortMultipartUpload" ], "Resource": [ "arn:aws:s3:::S3_Bucket_Created", "arn:aws:s3:::S3_Bucket_Created/*" ] } ] } ``` ------ Per ulteriori informazioni su queste autorizzazioni di scrittura S3, consulta la guida di [Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions). Se utilizzi una chiave KMS per crittografare i dati esportati, consulta quanto segue per le politiche IAM aggiuntive richieste. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kms:DescribeKey", "kms:Decrypt", "kms:GenerateDataKey*" ], "Resource": "arn:aws:kms:us-east-2:111122223333:key/*", "Condition": { "ForAnyValue:StringLike": { "kms:ResourceAliases": "alias/Alias_For_Generated_Key" } } }, { "Effect": "Allow", "Action": [ "kms:CreateGrant" ], "Resource": "arn:aws:kms:us-east-2:111122223333:key/*", "Condition": { "ForAnyValue:StringEquals": { "kms:EncryptionContextKeys": "aws:timestream:database_name" }, "Bool": { "kms:GrantIsForAWSResource": true }, "StringLike": { "kms:ViaService": "timestream.us-east-2.amazonaws.com" }, "ForAnyValue:StringLike": { "kms:ResourceAliases": "alias/Alias_For_Generated_Key" } } } ] } ``` ------ # Le migliori pratiche per UNLOAD from Timestream per LiveAnalytics Di seguito sono riportate le procedure consigliate relative al comando UNLOAD. + La quantità di dati che può essere esportata nel bucket S3 utilizzando il `UNLOAD` comando non è limitata. Tuttavia, la query scade dopo 60 minuti e consigliamo di esportare non più di 60 GB di dati in una singola query. Se devi esportare più di 60 GB di dati, suddividi il lavoro su più query. + Sebbene sia possibile inviare migliaia di richieste a S3 per caricare i dati, si consiglia di parallelizzare le operazioni di scrittura su più prefissi S3. [Fai](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) riferimento alla documentazione qui. La velocità di chiamata all'API S3 potrebbe essere limitata quando più readers/writers utenti accedono alla stessa cartella. + Dato il limite alla lunghezza della chiave S3 per la definizione di un prefisso, consigliamo di avere nomi di bucket e cartelle entro 10-15 caratteri, specialmente quando si utilizza la clausola. `partitioned_by` + Quando ricevi un 4XX o 5XX per le query contenenti l'`UNLOAD`istruzione, è possibile che i risultati parziali vengano scritti nel bucket S3. Timestream for LiveAnalytics non elimina alcun dato dal bucket. Prima di eseguire un'altra `UNLOAD` query con la stessa destinazione S3, consigliamo di eliminare manualmente i file creati dalla query fallita. È possibile identificare i file scritti da una query fallita con i file corrispondenti`QueryExecutionId`. Per le query non riuscite, Timestream for LiveAnalytics non esporta un file manifest nel bucket S3. + Timestream for LiveAnalytics utilizza il caricamento in più parti per esportare i risultati delle query su S3. Quando ricevi un 4XX o 5XX da Timestream per le query contenenti un'istruzione UNLOAD, Timestream LiveAnalytics for evita al massimo il caricamento in più parti, LiveAnalytics ma è possibile che alcune parti incomplete rimangano incomplete. [Pertanto, ti consigliamo di impostare una pulizia automatica dei caricamenti incompleti in più parti nel tuo bucket S3 seguendo le linee guida riportate qui.](https://aws.amazon.com/blogs/aws-cloud-financial-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/) ## Consigli per accedere ai dati in formato CSV utilizzando il parser CSV + I parser CSV non consentono di avere lo stesso carattere nei caratteri delimiter, escape e quote. + Alcuni parser CSV non sono in grado di interpretare tipi di dati complessi come gli array, consigliamo di interpretarli tramite il deserializzatore JSON. ## Raccomandazioni per l'accesso ai dati in formato Parquet 1. Se il tuo caso d'uso richiede il supporto dei caratteri UTF-8 nello schema, noto anche come nome della colonna, ti consigliamo di utilizzare la libreria [Parquet-MR](https://github.com/apache/parquet-mr). 1. Il timestamp nei risultati è rappresentato da un numero intero a 12 byte () INT96 1. Le serie temporali verranno rappresentate come`array>`, le altre strutture annidate utilizzeranno i tipi di dati corrispondenti supportati nel formato Parquet ## Utilizzo della clausola partition\$1by + La colonna utilizzata nel `partitioned_by` campo deve essere l'ultima colonna nella query di selezione. Se nel `partitioned_by` campo viene utilizzata più di una colonna, le colonne devono essere le ultime colonne della query di selezione e nello stesso ordine in cui vengono utilizzate nel `partition_by` campo. + I valori delle colonne utilizzati per partizionare i dati (`partitioned_by`campo) possono contenere solo caratteri ASCII. Mentre Timestream for LiveAnalytics consente i caratteri UTF-8 nei valori, S3 supporta solo caratteri ASCII come chiavi oggetto. # Esempio di utilizzo di UNLOAD from Timestream per LiveAnalytics Supponiamo che stiate monitorando le metriche della sessione utente, le sorgenti di traffico e gli acquisti di prodotti del vostro sito di e-commerce. Stai utilizzando Timestream per LiveAnalytics ottenere informazioni in tempo reale sul comportamento degli utenti, sulle vendite di prodotti ed eseguire analisi di marketing sui canali di traffico (ricerca organica, social media, traffico diretto, campagne a pagamento e altri) che indirizzano i clienti al sito web. **Topics** + [Esportazione dei dati senza partizioni](#export-unload-example-sample-1) + [Partizionamento dei dati per canale](#export-unload-example-sample-2) + [Partizionamento dei dati per evento](#export-unload-example-sample-3) + [Partizionamento dei dati sia per canale che per evento](#export-unload-example-sample-4) + [File di manifesto e di metadati](#export-unload-example-manifest-metadata) + [Utilizzo dei crawler Glue per creare Glue Data Catalog](#export-unload-example-using-glue-crawlers) ## Esportazione dei dati senza partizioni Vuoi esportare gli ultimi due giorni dei tuoi dati in formato CSV. ``` UNLOAD(SELECT user_id, ip_address, event, session_id, measure_name, time, query, quantity, product_id, channel FROM sample_clickstream.sample_shopping WHERE time BETWEEN ago(2d) AND now()) TO 's3:///withoutpartition' WITH ( format='CSV', compression='GZIP') ``` ## Partizionamento dei dati per canale Desideri esportare i dati degli ultimi due giorni in formato CSV ma desideri avere i dati di ciascun canale di traffico in una cartella separata. A tale scopo, è necessario partizionare i dati utilizzando la `channel` colonna, come illustrato di seguito. ``` UNLOAD(SELECT user_id, ip_address, event, session_id, measure_name, time, query, quantity, product_id, channel FROM sample_clickstream.sample_shopping WHERE time BETWEEN ago(2d) AND now()) TO 's3:///partitionbychannel/' WITH ( partitioned_by = ARRAY ['channel'], format='CSV', compression='GZIP') ``` ## Partizionamento dei dati per evento Desideri esportare i dati degli ultimi due giorni in formato CSV ma desideri avere i dati per ogni evento in una cartella separata. A tale scopo, è necessario partizionare i dati utilizzando la `event` colonna, come illustrato di seguito. ``` UNLOAD(SELECT user_id, ip_address, channel, session_id, measure_name, time, query, quantity, product_id, event FROM sample_clickstream.sample_shopping WHERE time BETWEEN ago(2d) AND now()) TO 's3:///partitionbyevent/' WITH ( partitioned_by = ARRAY ['event'], format='CSV', compression='GZIP') ``` ## Partizionamento dei dati sia per canale che per evento Desiderate esportare i dati degli ultimi due giorni in formato CSV, ma desiderate che i dati per ogni canale e all'interno del canale memorizzino ogni evento in una cartella separata. A tale scopo, è necessario partizionare i dati utilizzando entrambe `channel` le `event` colonne, come illustrato di seguito. ``` UNLOAD(SELECT user_id, ip_address, session_id, measure_name, time, query, quantity, product_id, channel,event FROM sample_clickstream.sample_shopping WHERE time BETWEEN ago(2d) AND now()) TO 's3:///partitionbychannelevent/' WITH ( partitioned_by = ARRAY ['channel','event'], format='CSV', compression='GZIP') ``` ## File di manifesto e di metadati ### File manifest Il file manifest fornisce informazioni sull'elenco dei file che vengono esportati con l'esecuzione UNLOAD. Il file manifest è disponibile nel bucket S3 fornito con un nome di file:. `S3://bucket_name/__manifest.json` Il file manifest conterrà l'URL dei file nella cartella dei risultati, il numero di record e le dimensioni dei rispettivi file, e i metadati della query (ovvero i byte totali e le righe totali esportati in S3 per la query). ``` { "result_files": [ { "url":"s3://my_timestream_unloads/ec2_metrics/AEDAGANLHLBH4OLISD3CVOZZRWPX5GV2XCXRBKCVD554N6GWPWWXBP7LSG74V2Q_1448466917_szCL4YgVYzGXj2lS.gz", "file_metadata": { "content_length_in_bytes": 32295, "row_count": 10 } }, { "url":"s3://my_timestream_unloads/ec2_metrics/AEDAGANLHLBH4OLISD3CVOZZRWPX5GV2XCXRBKCVD554N6GWPWWXBP7LSG74V2Q_1448466917_szCL4YgVYzGXj2lS.gz", "file_metadata": { "content_length_in_bytes": 62295, "row_count": 20 } }, ], "query_metadata": { "content_length_in_bytes": 94590, "total_row_count": 30, "result_format": "CSV", "result_version": "Amazon Timestream version 1.0.0" }, "author": { "name": "Amazon Timestream", "manifest_file_version": "1.0" } } ``` ### Metadati Il file di metadati fornisce informazioni aggiuntive sul set di dati come il nome della colonna, il tipo di colonna e lo schema. Il file di metadati è disponibile nel bucket S3 fornito con un nome di file: S3: //bucket\$1name/ \$1 \$1metadata.json Di seguito è riportato un esempio di file di metadati. ``` { "ColumnInfo": [ { "Name": "hostname", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "region", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "measure_name", "Type": { "ScalarType": "VARCHAR" } }, { "Name": "cpu_utilization", "Type": { "TimeSeriesMeasureValueColumnInfo": { "Type": { "ScalarType": "DOUBLE" } } } } ], "Author": { "Name": "Amazon Timestream", "MetadataFileVersion": "1.0" } } ``` Le informazioni sulle colonne condivise nel file di metadati hanno la stessa struttura di quelle `ColumnInfo` inviate nella risposta dell'API Query per le `SELECT` query. ## Utilizzo dei crawler Glue per creare Glue Data Catalog 1. Accedi al tuo account con le credenziali di amministratore per la seguente convalida. 1. [Crea un database Crawler for Glue utilizzando le linee guida fornite qui.](https://docs.aws.amazon.com/glue/latest/ug/tutorial-add-crawler.html) Tieni presente che la cartella S3 da fornire nell'origine dati dovrebbe essere la cartella dei risultati, ad esempio. `UNLOAD` `s3://my_timestream_unloads/results` 1. [Esegui il crawler seguendo le linee guida riportate qui.](https://docs.aws.amazon.com/glue/latest/ug/tutorial-add-crawler.html#tutorial-add-crawler-step2) 1. Visualizza la tabella Glue. + Vai a **AWS Glue** → **Tabelle**. + Vedrai una nuova tabella creata con il prefisso della tabella fornito durante la creazione del crawler. + È possibile visualizzare lo schema e le informazioni sulla partizione facendo clic sulla visualizzazione dei dettagli della tabella. Di seguito sono riportati altri AWS servizi e progetti open source che utilizzano il AWS Glue Data Catalog. + **Amazon Athena**: per ulteriori informazioni, consulta [Comprendere tabelle, database e cataloghi di dati](https://docs.aws.amazon.com/athena/latest/ug/understanding-tables-databases-and-the-data-catalog.html) nella Guida per l'utente di Amazon Athena. + **Amazon Redshift** Spectrum — Per ulteriori informazioni, [consulta la sezione Interrogazione di dati esterni utilizzando Amazon Redshift Spectrum nella Amazon](https://docs.aws.amazon.com/redshift/latest/dg/c-using-spectrum.html) Redshift Database Developer Guide. + **Amazon EMR**: per ulteriori informazioni, consulta [Utilizzare politiche basate sulle risorse per l'accesso di Amazon EMR AWS a Glue Data Catalog nella Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Management Guide. + **AWS Client Glue Data Catalog per Apache Hive metastore** — Per ulteriori informazioni su questo progetto GitHub, consulta [AWS Glue Data Catalog Client for](https://github.com/awslabs/aws-glue-data-catalog-client-for-apache-hive-metastore) Apache Hive Metastore. # Limiti per UNLOAD from Timestream per LiveAnalytics Di seguito sono riportati i limiti relativi al comando. `UNLOAD` + La concorrenza per le query che utilizzano l'`UNLOAD`istruzione è pari a 1 query al secondo (QPS). Il superamento della frequenza di query potrebbe comportare una limitazione. + Le query contenenti `UNLOAD` istruzioni possono esportare al massimo 100 partizioni per query. Si consiglia di controllare il numero distinto della colonna selezionata prima di utilizzarla per partizionare i dati esportati. + Le interrogazioni contenenti `UNLOAD` dichiarazioni scadono dopo 60 minuti. + La dimensione massima dei file creati dall'`UNLOAD`istruzione in Amazon S3 è di 78 GB. Per altri limiti per Timestream per, vedi LiveAnalytics [QuoteQuote di default](ts-limits.md)