Para recursos semelhantes aos do Amazon Timestream para, considere o Amazon Timestream LiveAnalytics para InfluxDB. Ele oferece ingestão de dados simplificada e tempos de resposta de consulta de um dígito em milissegundos para análises em tempo real. Saiba mais [aqui](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html). 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á. # Usando UNLOAD para exportar os resultados da consulta para o S3 do Timestream para LiveAnalytics LiveAnalytics Por enquanto, o Amazon Timestream permite que você exporte os resultados da consulta para o Amazon S3 de forma econômica e segura usando a declaração. `UNLOAD` Usando a declaração `UNLOAD`, agora você pode exportar dados de séries temporais para buckets S3 selecionados no formato Apache Parquet ou Valor Separado por Vírgula (CSV), que oferece flexibilidade para armazenar, combinar e analisar seus dados de séries temporais com outros serviços. A declaração `UNLOAD` permite que você exporte os dados de forma compactada, o que reduz os dados transferidos e o espaço de armazenamento necessário. `UNLOAD` também suporta particionamento com base em atributos selecionados ao exportar os dados, melhorando o desempenho e reduzindo o tempo de processamento dos serviços a jusante que acessam os dados. Além disso, você pode usar as chaves gerenciadas do Amazon S3 (SSE-S3) ou as chaves gerenciadas do AWS Key Management Service (AWS KMS) (SSE-KMS) para criptografar seus dados exportados. ## Benefícios do UNLOAD do Timestream para LiveAnalytics Os principais benefícios de usar a declaração `UNLOAD` são os seguintes. + **Facilidade operacional**: com a declaração `UNLOAD`, você pode exportar gigabytes de dados em uma única solicitação de consulta no formato Apache Parquet ou CSV, oferecendo flexibilidade para selecionar o formato mais adequado às suas necessidades de processamento posterior e facilitando a criação de data lakes. + **Seguro e econômico**: a declaração `UNLOAD` fornece a capacidade de exportar seus dados para um bucket S3 de forma compactada e criptografar (SSE-KMS ou SSE\$1S3) seus dados usando chaves gerenciadas pelo cliente, reduzindo os custos de armazenamento de dados e protegendo contra acesso não autorizado. + **Desempenho**: Usando a declaração `UNLOAD`, você pode particionar os dados ao exportar para um bucket do S3. O particionamento dos dados permite que os serviços a jusante processem os dados em paralelo, reduzindo o tempo de processamento. Além disso, os serviços a jusante podem processar somente os dados de que precisam, reduzindo os recursos de processamento necessários e, portanto, os custos associados. ## Casos de uso de UNLOAD do Timestream for LiveAnalytics Você pode usar a declaração `UNLOAD` para gravar dados no seu bucket do S3 da seguinte forma. + **Crie um data warehouse**: você pode exportar gigabytes de resultados de consultas para o bucket do S3 e adicionar mais facilmente dados de séries temporais ao seu data lake. Você pode usar serviços como o Amazon Athena e o Amazon Redshift para combinar seus dados de séries temporais com outros dados relevantes para obter insights comerciais complexos. + **Crie pipelines de dados de IA e ML** — A `UNLOAD` declaração permite que você crie facilmente pipelines de dados para seus modelos de aprendizado de máquina que acessam dados de séries temporais, facilitando o uso de dados de séries temporais com serviços como Amazon e SageMaker Amazon EMR. + **Simplifique o processamento de ETL** — A exportação de dados para buckets do S3 pode simplificar o processo de execução de operações de extração, transformação, carregamento (ETL) nos dados, permitindo que você use facilmente ferramentas ou serviços de terceiros, AWS como o AWS Glue, para processar e transformar os dados. # Conceitos UNLOAD ## Sintaxe ``` UNLOAD (SELECT statement) TO 's3://bucket-name/folder' WITH ( option = expression [, ...] ) ``` onde `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 = '' | } ``` ## Parâmetros Instrução SELECT A instrução de consulta usada para selecionar e recuperar dados de um ou mais Timestream para tabelas. LiveAnalytics ``` (SELECT column 1, column 2, column 3 from database.table where measure_name = "ABC" and timestamp between ago (1d) and now() ) ``` Cláusula TO ``` TO 's3://bucket-name/folder' ``` or ``` TO 's3://access-point-alias/folder' ``` A cláusula `TO` na instrução `UNLOAD` especifica o destino para a saída dos resultados da consulta. Você precisa fornecer o caminho completo, incluindo o nome do bucket do Amazon S3 ou o Amazon S3 com a access-point-alias localização da pasta no Amazon S3, onde o Timestream grava os objetos do arquivo de saída. LiveAnalytics O bucket do S3 deve ser de propriedade da mesma conta e da mesma região. Além do conjunto de resultados da consulta, o Timestream for LiveAnalytics grava os arquivos de manifesto e metadados na pasta de destino especificada. Cláusula PARTITIONED\$1BY ``` partitioned_by = ARRAY [col_name[,…] , (default: none) ``` A cláusula `partitioned_by` é usada em consultas para agrupar e analisar dados em um nível granular. Ao exportar os resultados da consulta para o bucket do S3, você pode optar por particionar os dados com base em uma ou mais colunas na consulta selecionada. Ao particionar os dados, os dados exportados são divididos em subconjuntos com base na coluna de partição e cada subconjunto é armazenado em uma pasta separada. Na pasta de resultados que contém os dados exportados, uma subpasta `folder/results/partition column = partition value/` é criada automaticamente. No entanto, observe que as colunas particionadas não estão incluídas no arquivo de saída. `partitioned_by` não é uma cláusula obrigatória na sintaxe. Se você optar por exportar os dados sem nenhum particionamento, poderá excluir a cláusula na sintaxe. **Example** Supondo que você esteja monitorando os dados do fluxo de cliques do seu site e tenha 5 canais de tráfego, que seriam `direct`, `Social Media`, `Organic Search`, `Other` e `Referral`. Ao exportar os dados, você pode optar por particioná-los usando a coluna `Channel`. Em sua pasta de dados `s3://bucketname/results` você terá cinco pastas, cada uma com o nome do respectivo canal. Por exemplo, `s3://bucketname/results/channel=Social Media/.`. Nessa pasta, você encontrará os dados de todos os clientes que acessaram seu site por meio do canal `Social Media`. Da mesma forma, você terá outras pastas para os canais restantes. Dados exportados particionados pela coluna Canal ![\[Folder structure showing channels: Direct, Organic search, Other, Referral, and Social media.\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/images/unload-results.png) FORMAT ``` format = [ '{ CSV | PARQUET }' , default: CSV ``` As palavras-chave para especificar o formato dos resultados da consulta gravados em seu bucket do S3. Você pode exportar os dados como um valor separado por vírgula (CSV) usando uma vírgula (,) como delimitador padrão ou no formato Apache Parquet, um formato de armazenamento em colunas abertas eficiente para análise. COMPRESSION ``` compression = [ '{ GZIP | NONE }' ], default: GZIP ``` Você pode compactar os dados exportados usando o algoritmo de compactação GZIP ou descompactá-los especificando a opção `NONE`. ENCRYPTION ``` encryption = [ '{ SSE_KMS | SSE_S3 }' ], default: SSE_S3 ``` Os arquivos de saída no Amazon S3 são criptografados usando a opção de criptografia selecionada. Além dos seus dados, os arquivos de manifesto e metadados também são criptografados com base na opção de criptografia selecionada. Atualmente, oferecemos suporte à criptografia SSE\$1S3 e SSE\$1KMS. O SSE\$1S3 é uma criptografia do lado do servidor com o Amazon S3 criptografando os dados usando criptografia padrão de criptografia avançada (AES) de 256 bits. O SSE\$1KMS é uma criptografia do lado do servidor para criptografar dados usando chaves gerenciadas pelo cliente. KMS\$1KEY ``` kms_key = '' ``` A chave KMS é uma chave definida pelo cliente para criptografar os resultados da consulta exportada. A chave KMS é gerenciada com segurança pelo AWS Key Management Service (AWS KMS) e usada para criptografar arquivos de dados no Amazon S3. FIELD\$1DELIMITER ``` field_delimiter ='' , default: (,) ``` Ao exportar dados no formato CSV, este campo especifica o único caractere ASCII usado para separar campos no arquivo de saída, como um caractere de barra vertical (\$1), uma vírgula (,) ou uma tabulação (\$1t). O delimitador padrão para arquivos CSV é uma vírgula. Se um valor em seus dados contiver o delimitador escolhido, o delimitador será citado com um caractere de aspa. Por exemplo, se o valor em seus dados contiver `Time,stream`, esse valor será cotado como `"Time,stream"` nos dados exportados. O caractere de aspas usado pelo Timestream para LiveAnalytics são aspas duplas (“). Evite especificar o caractere de retorno do carro (ASCII 13, hexadecimal `0D`, texto '\$1r') ou o caractere de quebra de linha (ASCII 10, hexadecimal 0A, texto '\$1n') como `FIELD_DELIMITER` se você quiser incluir cabeçalhos no CSV, pois isso impedirá que muitos analisadores consigam analisar os cabeçalhos corretamente na saída CSV resultante. ESCAPED\$1BY ``` escaped_by = '', default: (\) ``` Ao exportar os dados no formato CSV, esse campo especifica o caractere que deve ser tratado como um caractere de escape no arquivo de dados gravado no bucket do S3. O escape acontece nos seguintes cenários: 1. Se o valor em si contiver o caractere de aspa (“), ele será escapado usando um caractere de escape. Por exemplo, se o valor for `Time"stream`, onde (\$1) é o caractere de escape configurado, ele será escapado como `Time\"stream`. 1. Se o valor contiver o caractere de escape configurado, ele será escapado. Por exemplo, se o valor for `Time\stream`, ele será escapado como `Time\\stream`. Se a saída exportada contiver tipos de dados complexos, como matrizes, linhas ou séries temporais, ela será serializada como uma string JSON. Veja um exemplo a seguir. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/export-unload-concepts.html) INCLUDE\$1HEADER ``` include_header = 'true' , default: 'false' ``` Ao exportar os dados no formato CSV, esse campo permite incluir nomes de colunas como a primeira linha dos arquivos de dados CSV exportados. Os valores aceitos são 'true' e 'false' e o valor padrão é 'false'. Opções de transformação de texto, como `escaped_by` e `field_delimiter`, também se aplicam aos cabeçalhos. Ao incluir cabeçalhos, é importante que você não selecione um caractere de retorno de carro (ASCII 13, hexadecimal 0D, texto '\$1r') ou um caractere de quebra de linha (ASCII 10, hexadecimal 0A, texto '\$1n') como o `FIELD_DELIMITER`, pois isso impedirá que muitos analisadores consigam analisar os cabeçalhos corretamente na saída CSV resultante. MAX\$1FILE\$1SIZE ``` max_file_size = 'X[MB|GB]' , default: '78GB' ``` Esse campo especifica o tamanho máximo dos arquivos que a declaração `UNLOAD` cria no Amazon S3. A declaração `UNLOAD` pode criar vários arquivos, mas o tamanho máximo de cada arquivo gravado no Amazon S3 será aproximadamente o especificado nesse campo. O valor do campo deve ser de 16 MB a 78 GB, inclusive. Isso pode ser especificado em números inteiros como `12GB`, ou em decimais como `0.5GB` ou `24.7MB`. O valor padrão é 78 GB. O tamanho real do arquivo é aproximado quando o arquivo está sendo gravado, então o tamanho máximo real pode não ser exatamente igual ao número especificado. ## O que é gravado no meu bucket do S3? Para cada consulta UNLOAD executada com sucesso, o Timestream for LiveAnalytics grava os resultados da consulta, o arquivo de metadados e o arquivo de manifesto no bucket do S3. Se você particionou os dados, você tem todas as pastas de partição na pasta de resultados. O arquivo de manifesto contém uma lista dos arquivos que foram gravados pelo comando UNLOAD. O arquivo de metadados contém informações que descrevem as características, propriedades e atributos dos dados gravados. ## Qual é o nome do arquivo exportado? O nome do arquivo exportado contém dois componentes, o primeiro componente é o QueryID e o segundo componente é um identificador exclusivo. Arquivos CSV ``` S3://bucket_name/results/_.csv S3://bucket_name/results/=/_.csv ``` Arquivo CSV compactado ``` S3://bucket_name/results/=/_.gz ``` Arquivo Parquet ``` S3://bucket_name/results/=/_.parquet ``` Arquivos de metadados e de manifesto ``` S3://bucket_name/__manifest.json S3://bucket_name/__metadata.json ``` Como os dados no formato CSV são armazenados em um nível de arquivo, quando você compactar os dados ao exportar para o S3, o arquivo terá uma extensão “.gz”. No entanto, os dados no Parquet são compactados no nível da coluna, portanto, mesmo quando você compacta os dados durante a exportação, o arquivo ainda terá a extensão .parquet. ## Quais informações cada arquivo contém? ### Arquivo manifesto O arquivo de manifesto fornece informações sobre a lista de arquivos que são exportados com a execução do UNLOAD. O arquivo de manifesto está disponível no bucket S3 fornecido com um nome de arquivo: `s3:///__manifest.json`. O arquivo de manifesto conterá o URL dos arquivos na pasta de resultados, o número de registros e o tamanho dos respectivos arquivos e os metadados da consulta (que são o total de bytes e o total de linhas exportadas para a consulta no S3). ``` { "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" } } ``` ### Metadados O arquivo de metadados fornece informações adicionais sobre o conjunto de dados, como nome da coluna, tipo de coluna e esquema. O arquivo de metadados está disponível no bucket S3 fornecido com um nome de arquivo: S3://bucket\$1name/\$1\$1metadata.json Veja a seguir um exemplo de um arquivo de metadados. ``` { "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" } } ``` As informações da coluna compartilhadas no arquivo de metadados têm a mesma estrutura que `ColumnInfo` enviadi na resposta da API de consulta para consultas `SELECT`. ### Resultados A pasta de resultados contém seus dados exportados no formato Apache Parquet ou CSV. ## Exemplo Quando você envia uma consulta `UNLOAD` como a abaixo por meio da API de consulta, ``` 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') ``` a resposta da consulta `UNLOAD` terá 1 linha \$1 3 colunas. Essas 3 colunas são: + linhas do tipo BIGINT - indicando o número de linhas exportadas + Arquivo de metadados do tipo VARCHAR - que é o URI S3 do arquivo de metadados exportado + ManifestFile do tipo VARCHAR - que é o URI S3 do arquivo de manifesto exportado Você receberá a seguinte resposta da API de consulta: ``` { "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 } } ``` ## Tipos de dados A `UNLOAD` instrução suporta todos os tipos de dados da linguagem de consulta Timestream LiveAnalytics for descrita em[Tipos de dados compatíveis](supported-data-types.md), exceto e. `time` `unknown` # Pré-requisitos para UNLOAD do Timestream para LiveAnalytics A seguir estão os pré-requisitos para gravar dados no S3 usando `UNLOAD` o Timestream for. LiveAnalytics + Você deve ter permissão para ler dados do Timestream para que as LiveAnalytics tabelas sejam usadas em um `UNLOAD` comando. + Você deve ter um bucket do Amazon S3 na mesma AWS região do seu Timestream para obter recursos. LiveAnalytics + Para o bucket do S3 selecionado, certifique-se de que a [política do bucket do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html) também tenha permissões para permitir que o Timestream exporte LiveAnalytics os dados. + As credenciais usadas para executar a `UNLOAD` consulta devem ter as permissões necessárias de AWS Identity and Access Management (IAM) que permitam ao Timestream gravar os dados no S3 LiveAnalytics . Um exemplo de política seria o seguinte: ------ #### [ 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/*" ] } ] } ``` ------ Para obter mais informações sobre essas permissões de gravação no S3, consulte o [Guia do Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions). Se você estiver usando uma chave KMS para criptografar os dados exportados, consulte a seguir as políticas do IAM adicionais necessárias. ------ #### [ 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" } } } ] } ``` ------ # Melhores práticas para UNLOAD do Timestream for LiveAnalytics A seguir estão as práticas recomendadas relacionadas ao comando UNLOAD. + A quantidade de dados que pode ser exportada para o bucket do S3 usando o comando `UNLOAD` não é limitada. No entanto, o tempo limite da consulta é de 60 minutos e recomendamos exportar no máximo 60 GB de dados em uma única consulta. Se você precisar exportar mais de 60 GB de dados, divida o trabalho em várias consultas. + Embora você possa enviar milhares de solicitações ao S3 para carregar os dados, é recomendável paralelizar as operações de gravação em vários prefixos do S3. Consulte a documentação [aqui](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html). A taxa de chamadas da API S3 pode ser reduzida quando vários readers/writers acessam a mesma pasta. + Dado o limite do tamanho da chave do S3 para definir um prefixo, recomendamos ter nomes de bucket e pasta dentro de 10 a 15 caracteres, especialmente ao usar a cláusula `partitioned_by`. + Quando você recebe um 4XX ou 5XX para consultas contendo a declaração `UNLOAD`, é possível que resultados parciais sejam gravados no bucket do S3. O Timestream for LiveAnalytics não exclui nenhum dado do seu bucket. Antes de executar outra consulta `UNLOAD` com o mesmo destino do S3, recomendamos excluir manualmente os arquivos criados pela consulta com falha. Você pode identificar os arquivos gravados por uma consulta com falha com o `QueryExecutionId` correspondente. Para consultas com falha, o Timestream for LiveAnalytics não exporta um arquivo de manifesto para o bucket do S3. + O Timestream for LiveAnalytics usa o upload de várias partes para exportar os resultados da consulta para o S3. Quando você recebe um 4XX ou 5XX do Timestream for LiveAnalytics para consultas contendo uma instrução UNLOAD, o Timestream for LiveAnalytics faz o melhor possível para interromper o upload de várias partes, mas é possível que algumas partes incompletas sejam deixadas para trás. Portanto, recomendamos configurar uma limpeza automática de uploads incompletos de várias partes em seu bucket do S3 seguindo as diretrizes descritas [aqui](https://aws.amazon.com/blogs/aws-cloud-financial-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/). ## Recomendações para acessar dados no formato CSV usando o analisador CSV + Os analisadores CSV não permitem que você tenha o mesmo caractere em caracteres delimitadores, de escape e de aspas. + Alguns analisadores CSV não conseguem interpretar tipos de dados complexos, como matrizes. Recomendamos interpretá-los usando o desserializador JSON. ## Recomendações para acessar dados no formato Parquet 1. Se seu caso de uso exigir suporte a caracteres UTF-8 no esquema, também conhecido como nome da coluna, recomendamos usar a [biblioteca Parquet-mr](https://github.com/apache/parquet-mr). 1. O timestamp em seus resultados é representado como um inteiro de 12 bytes () INT96 1. As séries temporais serão representadas como `array>`, outras estruturas aninhadas usarão os tipos de dados correspondentes suportados no formato Parquet ## Usando a cláusula partition\$1by + A coluna usada no campo `partitioned_by` deve ser a última coluna na consulta selecionada. Se mais de uma coluna for usada no campo `partitioned_by`, as colunas deverão ser as últimas colunas na consulta de seleção e na mesma ordem em que foram usadas no campo `partition_by`. + Os valores da coluna usados para particionar os dados (campo `partitioned_by`) podem conter somente caracteres ASCII. Enquanto o Timestream for LiveAnalytics permite caracteres UTF-8 nos valores, o S3 suporta somente caracteres ASCII como chaves de objeto. # Exemplo de caso de uso para UNLOAD do Timestream para LiveAnalytics Suponha que você esteja monitorando as métricas da sessão do usuário, as fontes de tráfego e as compras de produtos do seu site de e-commerce. Você está usando o Timestream LiveAnalytics para obter informações em tempo real sobre o comportamento do usuário, vendas de produtos e realizar análises de marketing em canais de tráfego (pesquisa orgânica, mídia social, tráfego direto, campanhas pagas e outros) que direcionam os clientes ao site. **Topics** + [Exportando os dados sem partições](#export-unload-example-sample-1) + [Particionamento de dados por canal](#export-unload-example-sample-2) + [Particionamento de dados por evento](#export-unload-example-sample-3) + [Particionamento de dados por canal e evento](#export-unload-example-sample-4) + [Arquivos de manifesto e metadados](#export-unload-example-manifest-metadata) + [Usando crawlers Glue para criar o catálogo de dados Glue](#export-unload-example-using-glue-crawlers) ## Exportando os dados sem partições Você quer exportar os últimos dois dias dos seus dados no 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') ``` ## Particionamento de dados por canal Você quer exportar os últimos dois dias de dados no formato CSV, mas gostaria de ter os dados de cada canal de tráfego em uma pasta separada. Para isso, você deve particionar dados usando a coluna `channel`, conforme exibido a seguir. ``` 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') ``` ## Particionamento de dados por evento Você quer exportar os últimos dois dias de dados no formato CSV, mas gostaria de ter os dados de cada evento em uma pasta separada. Para isso, você deve particionar dados usando a coluna `event`, conforme exibido a seguir. ``` 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') ``` ## Particionamento de dados por canal e evento Você quer exportar os últimos dois dias de dados no formato CSV, mas gostaria que os dados de cada canal e dentro do canal armazenassem cada evento em uma pasta separada. Para fazer isso, você precisa particionar os dados usando a coluna `channel` e `event`, conforme mostrado a seguir. ``` 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') ``` ## Arquivos de manifesto e metadados ### Arquivo manifesto O arquivo de manifesto fornece informações sobre a lista de arquivos que são exportados com a execução do UNLOAD. O arquivo de manifesto está disponível no bucket S3 fornecido com um nome de arquivo: `S3://bucket_name/__manifest.json`. O arquivo de manifesto conterá o URL dos arquivos na pasta de resultados, o número de registros e o tamanho dos respectivos arquivos e os metadados da consulta (que são o total de bytes e o total de linhas exportadas para a consulta no S3). ``` { "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" } } ``` ### Metadados O arquivo de metadados fornece informações adicionais sobre o conjunto de dados, como nome da coluna, tipo de coluna e esquema. O arquivo de metadados está disponível no bucket S3 fornecido com um nome de arquivo: S3://bucket\$1name/\$1\$1metadata.json Veja a seguir um exemplo de um arquivo de metadados. ``` { "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" } } ``` As informações da coluna compartilhadas no arquivo de metadados têm a mesma estrutura que `ColumnInfo` enviadi na resposta da API de consulta para consultas `SELECT`. ## Usando crawlers Glue para criar o catálogo de dados Glue 1. Faça login em sua conta com credenciais de administrador para a seguinte validação. 1. Crie um Crawler para banco de dados do Glue usando as diretrizes fornecidas [aqui](https://docs.aws.amazon.com/glue/latest/ug/tutorial-add-crawler.html). Observe que a pasta S3 a ser fornecida na fonte de dados deve ser a pasta de resultados `UNLOAD`, como `s3://my_timestream_unloads/results`. 1. Execute o crawler seguindo as diretrizes [aqui](https://docs.aws.amazon.com/glue/latest/ug/tutorial-add-crawler.html#tutorial-add-crawler-step2). 1. Veja a tabela do Glue. + Vá para **AWS Glue** → **Tabelas**. + Você verá uma nova tabela criada com o prefixo de tabela fornecido ao criar o crawler. + Você pode ver as informações do esquema e da partição clicando na exibição de detalhes da tabela. A seguir estão outros AWS serviços e projetos de código aberto que usam o AWS Glue Data Catalog. + **Amazon Athena** – para obter mais informações, consulte [Noções básicas de tabelas, bancos de dados e catálogos de dados](https://docs.aws.amazon.com/athena/latest/ug/understanding-tables-databases-and-the-data-catalog.html) no Manual do usuário do Amazon Athena. + **Amazon Redshift Spectrum** – para obter mais informações, consulte [Consultando dados externos usando o Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/dg/c-using-spectrum.html) no Guia do desenvolvedor de banco de dados do Amazon Redshift. + **Amazon EMR** — Para obter mais informações, consulte [Usar políticas baseadas em recursos para o acesso do Amazon EMR ao Glue AWS Data Catalog no Guia de Gerenciamento do](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Amazon EMR. + **AWS Cliente Glue Data Catalog para Apache Hive metastore** — Para obter mais informações sobre esse projeto GitHub, consulte [AWS Glue Data Catalog Client para](https://github.com/awslabs/aws-glue-data-catalog-client-for-apache-hive-metastore) Apache Hive Metastore. # Limites para UNLOAD do Timestream para LiveAnalytics A seguir estão os limites relacionados ao comando `UNLOAD`. + A simultaneidade para consultas usando a declaração `UNLOAD` é de 1 consulta por segundo (QPS). Exceder a taxa de consulta pode causar um controle de utili,zação. + As consultas contendo declarações `UNLOAD` podem exportar no máximo 100 partições por consulta. Recomendamos verificar a contagem distinta da coluna selecionada antes de usá-la para particionar os dados exportados. + O tempo limite das consultas contendo a declaração `UNLOAD` é de 60 minutos. + O tamanho máximo dos arquivos que a declaração `UNLOAD` cria no Amazon S3 é 78 GB. Para outros limites do Timestream for LiveAnalytics, consulte [CotasCotas padrão](ts-limits.md)