# Conectar-se à fonte de dados
Você pode usar o Amazon Athena para consultar os dados armazenados em diferentes locais e formatos em um *conjunto de dados*. Esse conjunto de dados pode estar em CSV, JSON, Avro, Parquet ou outro formato.
As tabelas e os bancos de dados com os quais você trabalha no Athena para executar consultas são baseados em *metadados*. Metadados são dados sobre os dados subjacentes em seu conjunto de dados. A forma como esses metadados descrevem seu conjunto de dados é chamada de *esquema*. Por exemplo, um nome de tabela, os nomes de coluna na tabela e o tipo de dados de cada coluna são esquemas, salvos como metadados, que descrevem um conjunto de dados subjacente. No Athena, chamamos um sistema para organizar metadados de *catálogo de dados* ou de *metastore*. A combinação de um conjunto de dados e o catálogo de dados que o descreve é chamada de *fonte de dados*.
A relação dos metadados com um conjunto de dados subjacente depende do tipo de fonte de dados com a qual você trabalha. Fontes de dados relacionais como MySQL, PostgreSQL e SQL Server integram totalmente os metadados ao conjunto de dados. Nesses sistemas, os metadados são gravados com maior frequência quando os dados são gravados. Outras fontes de dados, como aquelas criadas usando o [Hive](https://hive.apache.org), permitem definir metadados em tempo real ao ler o conjunto de dados. O conjunto de dados pode estar em uma variedade de formatos, por exemplo, CSV, JSON, Parquet ou Avro.
O Athena tem compatibilidade nativa com o AWS Glue Data Catalog. O AWS Glue Data Catalog é um catálogo de dados desenvolvido com base em outros conjuntos e origens de dados, como Amazon S3, Amazon Redshift e Amazon DynamoDB. Você também pode conectar o Athena a outras origens de dados usando uma variedade de conectores.
**Topics**
+ [Usar o AWS Glue Data Catalog para se conectar aos seus dados](data-sources-glue.md)
+ [Usar a consulta federada do Amazon Athena](federated-queries.md)
+ [Usar o Amazon DataZone no Athena](datazone-using.md)
+ [Usar um metastore externa do Hive](connect-to-data-source-hive.md)
+ [Gerenciar suas fontes de dados](data-sources-managing.md)
# Usar o AWS Glue Data Catalog para se conectar aos seus dados
O Athena usa o AWS Glue Data Catalog para armazenar metadados, como nomes de tabela e de coluna para se conectar aos dados armazenados no Amazon S3. Essas informações de metadados tornam-se os bancos de dados, as tabelas e as visualizações que são exibidas no editor de consultas do Athena.
Ao usar o Athena com o AWS Glue Data Catalog, é possível usar o AWS Glue para criar bancos de dados e tabelas (esquema) para serem consultados no Athena ou usar o Athena para criar um esquema e usá-lo no AWS Glue e nos serviços relacionados.
Para definir informações de esquema para o AWS Glue, você pode usar um formulário no console do Athena, usar o editor de consultas no Athena ou criar um crawler do AWS Glue no console do AWS Glue. Os crawlers do AWS Glue inferem automaticamente o esquema de banco de dados e tabela dos seus dados do Amazon S3. Usar um formulário oferece mais personalização. Escrever suas próprias instruções `CREATE TABLE` exige mais esforço, mas oferece mais controle. Para obter mais informações, consulte [CREATE TABLE](create-table.md).
## Recursos adicionais
+ Para obter mais informações sobre o AWS Glue Data Catalog, consulte [Data Catalog e crawlers no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) no *Guia do desenvolvedor do AWS Glue*.
+ Para ver um artigo ilustrativo que mostra como usar o AWS Glue e o Athena para processar dados XML, consulte [Process and analyze highly nested and large XML files using AWS Glue and Amazon Athena](https://aws.amazon.com/blogs/big-data/process-and-analyze-highly-nested-and-large-xml-files-using-aws-glue-and-amazon-athena/) no blog do AWS Big Data.
+ São feitas cobranças separadas pelo uso do AWS Glue. Para obter mais informações, consulte [Preços do AWS Glue](https://aws.amazon.com/glue/pricing).
**Topics**
+ [Recursos adicionais](#glue-additional-resources)
+ [Registrar e usar catálogos de dados no Athena](gdc-register.md)
+ [Registrar um catálogo de dados de outra conta](data-sources-glue-cross-account.md)
+ [Controlar o acesso a catálogos de dados com políticas do IAM](datacatalogs-iam-policy.md)
+ [Usar um formulário no console do Athena para adicionar uma tabela do AWS Glue](data-sources-glue-manual-table.md)
+ [Usar um crawler para adicionar uma tabela](schema-crawlers.md)
+ [Otimizar consultas com indexação e filtragem de partições do AWS Glue](glue-best-practices-partition-index.md)
+ [Usar a AWS CLI para recriar um banco de dados do AWS Glue e suas tabelas](glue-recreate-db-and-tables-cli.md)
+ [Criação de tabelas para trabalhos de ETL](schema-classifier.md)
+ [Trabalhar com dados CSV no AWS Glue](schema-csv.md)
+ [Trabalhar com dados geoespaciais no AWS Glue](schema-geospatial.md)
# Registrar e usar catálogos de dados no Athena
O Athena é compatível com a montagem e conexão com vários catálogos de dados.
+ Você pode montar dados do Amazon Redshift no AWS Glue Data Catalog e consultá-los no Athena sem precisar copiar ou mover dados. Para obter mais informações, consulte [Bringing Amazon Redshift data into the AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-namespaces-datacatalog.html).
+ Conecte o AWS Glue Data Catalog a fontes de dados externas usando conexões do AWS Glue e crie catálogos federados para gerenciar centralmente as permissões aos dados com controle de acesso refinado usando o Lake Formation. Para obter mais informações, consulte [Registrar sua conexão como um Glue Data Catalog](register-connection-as-gdc.md).
+ Crie catálogos com base em buckets de tabela do Amazon S3 e use o Lake Formation para gerenciar centralmente as permissões de acesso e restringir o acesso do usuário aos objetos dentro do bucket de tabela. Para obter mais informações, consulte [Working with Amazon S3 Tables and table buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables.html) no Guia do usuário do Amazon S3.
**nota**
Para qualquer catálogo do Glue, você só pode registrar um catálogo de vários níveis, como `123412341234:my_catalog/my_child`. Você não pode registrar um catálogo de nível único como `123412341234:linkcontainer` ou `my_catalog`. Catálogos de nível único só podem ser consultados usando o catálogo de dados Glue diretamente na consulta do Athena. Para obter mais informações, consulte [Consultar catálogos de dados do AWS Glue no Athena](gdc-register-query-the-data-source.md).
**Topics**
+ [Registrar catálogos de dados do Redshift no Athena](gdc-register-rs.md)
+ [Registrar catálogos federados no Athena](gdc-register-federated.md)
+ [Registrar catálogos de buckets de tabela do S3 e consultar tabelas no Athena](gdc-register-s3-table-bucket-cat.md)
+ [Consultar catálogos de dados do AWS Glue no Athena](gdc-register-query-the-data-source.md)
# Registrar catálogos de dados do Redshift no Athena
O Athena pode ler e gravar dados armazenados em clusters do Redshift ou namespaces com tecnologia sem servidor registrados no AWS Glue Data Catalog. Isso funciona em conjunto com o AWS Lake Formation, que fornece segurança e governança centralizadas, garantindo que o acesso aos dados seja gerenciado de modo consistente em diferentes mecanismos de consulta e mantendo controles de acesso refinados para os dados compartilhados do Redshift.
## Considerações e limitações
+ **Visões materializadas**: as visões materializadas do Amazon Redshift podem ser consultadas no Athena, mas não há compatibilidade com a criação de visões materializadas usando o Athena ou o Spark.
+ Não há compatibilidade com as operações de DDL, incluindo a definição da configuração do AWS Glue Data Catalog e as operações nas tabelas de armazenamento gerenciado do Amazon Redshift.
## Pré-requisitos
Antes que você possa consultar um catálogo de dados do AWS Glue pelo Athena, conclua as seguintes tarefas:
1. Crie e registre um cluster do Amazon Redshift ou namespace com tecnologia sem servidor no AWS Glue Data Catalog. Para obter mais informações, consulte [Registering a cluster to the AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/register-cluster.html) ou [Registering namespaces to the AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless_datasharing-register-namespace.html) no Guia de gerenciamento do Amazon Redshift.
1. Crie um catálogo de dados do AWS Lake Formation usando o namespace registrado. Para obter mais informações, consulte [Creating Amazon Redshift federated catalogs](https://docs.aws.amazon.com/lake-formation/latest/dg/create-ns-catalog.html) no Guia do desenvolvedor do AWS Lake Formation.
1. (Opcional) Use o Lake Formation para definir controles de acesso refinados no catálogo. Para obter mais informações, consulte [Bringing your data into the AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/bring-your-data-overview.html) no Guia do desenvolvedor do AWS Lake Formation.
## Registrar um catálogo de dados do Redshift com o console do Athena
Para registrar um catálogo de dados do Redshift no console do Athena, execute as etapas a seguir.
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Em **Escolher uma fonte de dados**, escolha **Amazon S3 - AWS Glue Data Catalog**.
1. Na seção **AWS Glue Data Catalog**, em **Conta da fonte de dados**, escolha **AWS Glue Data Catalog nesta conta**.
1. Em **Criar uma tabela ou registrar um catálogo**, escolha **Registrar um novo catálogo do AWS Glue**.
1. Na seção **Detalhes da fonte de dados**, em **Nome da fonte de dados**, insira o nome que deseja usar para especificar a fonte de dados em suas consultas SQL ou use o nome padrão gerado.
1. Em **Catálogo**, escolha **Procurar** para pesquisar uma lista de catálogos do AWS Glue na mesma conta. Se você não encontrar nenhum catálogo existente, crie um no [console do AWS Glue](https://console.aws.amazon.com/glue/).
1. Na caixa de diálogo **Procurar catálogos do AWS Glue**, selecione o catálogo que deseja usar e selecione **Escolher**.
1. (Opcional) Em **Tags**, adicione pares de chave/valor que queira associar à fonte de dados.
1. Escolha **Próximo**.
1. Na página **Revisar e criar**, verifique se as informações inseridas estão corretas e selecione **Criar fonte de dados**.
# Registrar catálogos federados no Athena
Após criar conexões com fontes de dados federadas, você poderá registrá-las como catálogos de dados federados para simplificar a descoberta de dados e gerenciar o acesso aos dados com permissões refinadas usando o Lake Formation. Para obter mais informações, consulte [Registrar sua conexão como um Glue Data Catalog](register-connection-as-gdc.md).
## Considerações e limitações
+ Não há compatibilidade com operações de DDL em catálogos federados.
+ É possível registrar os seguintes conectores para integração com o AWS Glue a fim de oferecer um controle de acesso refinado:
+ [Azure Data Lake Storage](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [BigQuery](connectors-bigquery.md)
+ [CMDB](connectors-cmdb.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [Google Cloud Storage](connectors-gcs.md)
+ [HBase](connectors-hbase.md)
+ [MySQL](connectors-mysql.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [do SQL Server](connectors-microsoft-sql-server.md)
+ [Timestream](connectors-timestream.md)
+ [TPC-DS](connectors-tpcds.md)
+ Quando você cria um link de recurso para a federação de conexões do Glue, o nome do [link de recurso](https://docs.aws.amazon.com/lake-formation/latest/dg/create-resource-link-database.html) precisa ser igual ao nome do banco de dados do produtor.
+ Atualmente, somente nomes de tabelas e colunas em minúsculas são reconhecidos, mesmo que a fonte de dados não diferencie maiúsculas de minúsculas.
# Registrar catálogos de buckets de tabela do S3 e consultar tabelas no Athena
Os buckets de tabela do Amazon S3 são um tipo de bucket no Amazon S3 criado especificamente para armazenar dados tabulares nas tabelas do Apache Iceberg. Os buckets de tabela automatizam as tarefas de gerenciamento de tabelas, como compactação, gerenciamento de snapshots e coleta de resíduos, para otimizar continuamente o desempenho das consultas e minimizar os custos. Se você está apenas começando ou tem milhares de tabelas em seu ambiente do Iceberg, os buckets de tabela simplificam os data lakes em qualquer escala. Para obter mais informações, consulte [Buckets de tabela](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets.html).
## Considerações e limitações
+ Todas as operações de DDL aceitas em tabelas do Iceberg são compatíveis com tabelas do S3, com as seguintes exceções:
+ Não há suporte a `ALTER TABLE RENAME`, `CREATE VIEW` e `ALTER DATABASE`.
+ `OPTIMIZE` e `VACUUM`: é possível gerenciar a compactação e o gerenciamento de snapshots no S3. Para obter mais informações, consulte a [documentação de manutenção de tabelas do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html).
+ Não há suporte a consultas de DDL em tabelas do S3 registradas como fontes de dados do Athena.
+ Não há suporte à reutilização de resultados de consultas.
+ Em grupos de trabalho com criptografia SSE-KMS, CSE-KMS ativada, não é possível executar operações de gravação como `INSERT`, `UPDATE`, `DELETE` ou `MERGE` em tabelas do S3.
+ Em grupos de trabalho com a opção S3 Requester Pays ativada, não é possível executar operações de DML em tabelas do S3.
## Consultar tabelas do S3 via Athena
**Conclua estas etapas obrigatórias antes de consultar tabelas do S3 no Athena**
1. Crie um bucket de tabela do S3. Para obter mais informações, consulte [Creating a table bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-create.html) no Guia do usuário do Amazon Simple Storage Service.
1. Certifique-se de que a integração de seus buckets com o AWS Glue Data Catalog seja bem-sucedida. Para obter as permissões necessárias e as etapas de configuração, consulte [Prerequisites for S3 Tables integration](https://docs.aws.amazon.com/glue/latest/dg/s3tables-catalog-prerequisites.html) (Pré-requisitos para a integração do Tabelas do S3) e [Enabling S3 Tables integration with Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/enable-s3-tables-catalog-integration.html) (Como habilitar a integração do Tabelas do S3 com o Glue Data Catalog) no Guia do desenvolvedor do AWS Glue.
1. Para a entidade principal que você usa para executar consultas com o Athena, conceda permissões no catálogo do Tabelas do S3 usando uma das seguintes abordagens:
**Opção 1: usar permissões do IAM**
Ao usar o controle de acesso do IAM, sua entidade principal precisa de permissões tanto nos recursos AWS Glue Data Catalog quanto nos recursos do Tabelas do Amazon S3.
A lista a seguir contém todas as permissões `s3tables` necessárias para realizar qualquer operação DDL ou DML compatível com suas Tabelas do S3 no Athena:
+ `s3tables:GetTableBucket`
+ `s3tables:GetNamespace`
+ `s3tables:GetTable`
+ `s3tables:GetTableData`
+ `s3tables:PutTableData`
+ `s3tables:ListNamespaces`
+ `s3tables:ListTables`
+ `s3tables:DeleteNamespace`
+ `s3tables:DeleteTable`
+ `s3tables:CreateNamespace`
+ `s3tables:CreateTable`
+ `s3tables:UpdateTableMetadataLocation`
Aplique essas permissões a recursos específicos do bucket do Tabelas do S3 e do recursos do Tabelas do S3 ou use `*` como recurso para conceder acesso a todos os buckets e tabelas da sua conta. Essas permissões podem ser combinadas com a política gerenciada [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html) para permitir a funcionalidade completa.
**Opção 2: usar as permissões do Lake Formation**
Alternativamente, para habilitar o controle de acesso granular, você pode conceder permissões ao Lake Formation no catálogo do Tabelas do S3, seja por meio do console do Lake Formation ou AWS CLI. Isso requer o registro dos seus buckets da tabela do S3 como um local de dados do Lake Formation. Para obter mais informações, consulte [Criar um catálogo do Tabelas do Amazon S3 no AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html) no Guia do Desenvolvedor do Lake Formation.
------
#### [ Console de gerenciamento da AWS ]
1. Abra o console do AWS Lake Formation em [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) e acesse como administrador do data lake. Para obter mais informações sobre como criar um administrador de data lake, consulte [Create a data lake administrator](https://docs.aws.amazon.com/lake-formation/latest/dg/initial-lf-config.html#create-data-lake-admin).
1. No painel de navegação, escolha **Permissões de dados** e **Conceder**.
1. Na página **Conceder Permissões**, em **Entidades principais**, escolha a entidade principal que deseja usar para enviar uma consulta do Athena.
1. Em **Tags do LF ou recursos de catálogo**, escolha **Recursos do catálogo de dados nomeados**.
1. Em **Catálogos**, escolha um catálogo de dados do Glue que você criou com base na integração do seu bucket de tabela. Por exemplo, **:s3tablescatalog/*amzn-s3-demo-bucket*.
1. Em **Permissões de catálogo**, escolha **Super**.
1. Selecione **Conceder**.
------
#### [ AWS CLI ]
Execute o comando a seguir com o perfil de administrador do data lake do Lake Formation para conceder acesso à entidade principal que você usa para enviar consultas do Athena.
```
aws lakeformation grant-permissions \
--region \
--cli-input-json \
'{
"Principal": {
"DataLakePrincipalIdentifier": ":role/ExampleRole>"
},
"Resource": {
"Catalog": {
"Id":":s3tablescatalog/amzn-s3-demo-bucket"
}
},
"Permissions": ["ALL"]
}'
```
------
**Enviar consultas para tabelas do S3**
1. Envie uma consulta `CREATE DATABASE` do Athena com o usuário/perfil concedido acima. Neste exemplo, `s3tablescatalog` é o Catálogo de Dados do Glue principal criado com base na integração e ` s3tablescatalog/amzn-s3-demo-bucket` o Catálogo de Dados do Glue secundário criado para cada bucket de tabela do S3. Há duas maneiras de fazer a consulta.
------
#### [ Option 1 ]
Especifique o Catálogo de Dados do Glue secundário (`s3tablescatalog/amzn-s3-demo-bucket`) diretamente do console ou AWS CLI.
**Usar o Console de gerenciamento da AWS**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. No painel de navegação à esquerda, em **Nome da fonte de dados**, escolha **AwsDataCatalog**.
1. Em **Catálogo**, escolha **s3tablescatalog/*amzn-s3-demo-bucket***.
1. No editor de consultas, insira uma consulta, como `CREATE DATABASE test_namespace`.
**Usar o AWS CLI**
Execute o comando a seguir.
```
aws athena start-query-execution \
--query-string 'CREATE DATABASE `test_namespace`' \
--query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket"}' \
--work-group "primary"
```
------
#### [ Option 2 ]
Crie o catálogo de dados do Athena com base no Catálogo de Dados do Glue secundário no console do Athena e especifique-o como um catálogo na consulta. Para obter mais informações, consulte [Registrar catálogos de buckets de tabelas do S3 como fontes de dados do Athena](#gdc-register-s3-table-console-steps).
------
1. Com o banco de dados que você criou na etapa anterior, use `CREATE TABLE` para criar uma tabela. O exemplo a seguir cria uma tabela no banco de dados *`test_namespace`* que você criou anteriormente no catálogo `s3tablescatalog/amzn-s3-demo-bucket` do Glue.
------
#### [ Console de gerenciamento da AWS ]
1. No painel de navegação à esquerda, em **Nome da fonte de dados**, escolha **AwsDataCatalog**.
1. Em **Catálogo**, escolha **s3tablescatalog/*amzn-s3-demo-bucket***.
1. Em **Banco de dados**, escolha **test\$1namespace**.
1. No editor de consultas, execute a consulta a seguir.
```
CREATE TABLE daily_sales (
sale_date date,
product_category
string, sales_amount double)
PARTITIONED BY (month(sale_date))
TBLPROPERTIES ('table_type' = 'iceberg')
```
------
#### [ AWS CLI ]
Execute o comando a seguir.
```
aws athena start-query-execution \
--query-string "CREATE TABLE daily_sales (
sale_date date,
product_category
string, sales_amount double)
PARTITIONED BY (month(sale_date))
TBLPROPERTIES ('table_type' = 'iceberg')" \
--query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket", "Database":"test_namespace"}' \
--work-group "primary"
```
------
1. Insira dados na tabela que você criou na etapa anterior.
------
#### [ Console de gerenciamento da AWS ]
1. No painel de navegação à esquerda, em **Nome da fonte de dados**, escolha **AwsDataCatalog**.
1. Em **Catálogo**, escolha **s3tablescatalog/*amzn-s3-demo-bucket***.
1. Em **Banco de dados**, escolha **test\$1namespace**.
1. No editor de consultas, execute a consulta a seguir.
```
INSERT INTO daily_sales
VALUES
(DATE '2024-01-15', 'Laptop', 900.00),
(DATE '2024-01-15', 'Monitor', 250.00),
(DATE '2024-01-16', 'Laptop', 1350.00),
(DATE '2024-02-01', 'Monitor', 300.00);
```
------
#### [ AWS CLI ]
Execute o comando a seguir.
```
aws athena start-query-execution \
--query-string "INSERT INTO \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
VALUES
(DATE '2024-01-15', 'Laptop', 900.00),
(DATE '2024-01-15', 'Monitor', 250.00),
(DATE '2024-01-16', 'Laptop', 1350.00),
(DATE '2024-02-01', 'Monitor', 300.00)"\
--work-group "primary"
```
------
1. Após inserir os dados na tabela, você poderá consultá-los.
------
#### [ Console de gerenciamento da AWS ]
1. No painel de navegação à esquerda, em **Nome da fonte de dados**, escolha **AwsDataCatalog**.
1. Em **Catálogo**, escolha **s3tablescatalog/*amzn-s3-demo-bucket***.
1. Em **Banco de dados**, escolha **test\$1namespace**.
1. No editor de consultas, execute a consulta a seguir.
```
SELECT
product_category,
COUNT(*) AS units_sold,
SUM(sales_amount) AS total_revenue,
AVG(sales_amount) AS average_price
FROM
daily_sales
WHERE
sale_date BETWEEN DATE '2024-02-01'
AND DATE '2024-02-29'
GROUP BY
product_category
ORDER BY
total_revenue DESC
```
------
#### [ AWS CLI ]
Execute o comando a seguir.
```
aws athena start-query-execution \
--query-string "SELECT product_category,
COUNT(*) AS units_sold,
SUM(sales_amount) AS total_revenue,
AVG(sales_amount) AS average_price
FROM \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
WHERE sale_date BETWEEN DATE '2024-02-01' AND DATE '2024-02-29'
GROUP BY product_category
ORDER BY total_revenue DESC"\
--work-group "primary"
```
------
## Criar tabelas do S3 no Athena
O Athena oferece suporte à criação de tabelas em namespaces de tabela do S3 existentes ou namespaces criados no Athena com instruções `CREATE DATABASE`. Para criar uma tabela do S3 via Athena, a sintaxe é a mesma de quando você [cria uma tabela do Iceberg](querying-iceberg-creating-tables.md), exceto que você não especifica o `LOCATION`, conforme mostrado no exemplo a seguir.
```
CREATE TABLE
[db_name.]table_name (col_name data_type [COMMENT col_comment] [, ...] )
[PARTITIONED BY (col_name | transform, ... )]
[TBLPROPERTIES ([, property_name=property_value] )]
```
Você também pode criar tabelas do S3 usando instruções CREATE TABLE AS SELECT (CTAS). Para obter mais informações, consulte [CTAS para tabelas do S3](#ctas-s3-tables).
## Registrar catálogos de buckets de tabelas do S3 como fontes de dados do Athena
Para registrar catálogos de buckets de tabelas do S3 com o console do Athena, execute as etapas a seguir.
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Em **Escolher uma fonte de dados**, escolha **Amazon S3 - AWS Glue Data Catalog**.
1. Na seção **AWS Glue Data Catalog**, em **Conta da fonte de dados**, escolha **AWS Glue Data Catalog nesta conta**.
1. Em **Criar uma tabela ou registrar um catálogo**, escolha **Registrar um novo catálogo do AWS Glue**.
1. Na seção **Detalhes da fonte de dados**, em **Nome da fonte de dados**, insira o nome que deseja usar para especificar a fonte de dados em suas consultas SQL ou use o nome padrão gerado.
1. Em **Catálogo**, escolha **Procurar** para pesquisar uma lista de catálogos do AWS Glue na mesma conta. Se você não encontrar nenhum catálogo existente, crie um no [console do AWS Glue](https://console.aws.amazon.com/glue/).
1. Na caixa de diálogo **Procurar catálogos do AWS Glue**, selecione o catálogo que deseja usar e selecione **Escolher**.
1. (Opcional) Em **Tags**, adicione pares de chave/valor que queira associar à fonte de dados.
1. Escolha **Próximo**.
1. Na página **Revisar e criar**, verifique se as informações inseridas estão corretas e selecione **Criar fonte de dados**.
## CTAS para tabelas do S3
O Amazon Athena agora é compatível com operações CREATE TABLE AS SELECT (CTAS) para tabelas do S3. Esse atributo permite criar novas tabelas do S3 com base nos resultados de uma consulta SELECT.
Ao criar uma consulta CTAS para uma tabela do S3, há algumas diferenças importantes em relação às tabelas padrão do Athena:
+ Você deve omitir a propriedade de localização porque as tabelas do S3 gerenciam automaticamente seus próprios locais de armazenamento.
+ A propriedade `table_type` assume o padrão `ICEBERG`, portanto, você não precisa especificá-la explicitamente na consulta.
+ Se você não especificar um formato, o sistema usará automaticamente `PARQUET` como formato padrão para os dados.
+ Todas as outras propriedades seguem a mesma sintaxe das tabelas normais do Iceberg.
Antes de criar o Tabelas do S3 usando CTAS, verifique se você tem as permissões necessárias configuradas no IAM ou no AWS Lake Formation. Especificamente, você precisa de permissões para criar tabelas no catálogo de tabelas do S3. Sem essas permissões, suas operações CTAS não terão sucesso.
**nota**
Se a consulta CTAS não tiver sucesso, poderá ser necessário excluir a tabela usando a [API de tabelas do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-delete.html) antes de tentar executar a consulta novamente. Não é possível usar as instruções `DROP TABLE` do Athena para remover a tabela que foi parcialmente criada pela consulta.
**Exemplo**
```
CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name"
WITH (
format = 'PARQUET'
)
AS SELECT *
FROM source_table;
```
# Consultar catálogos de dados do AWS Glue no Athena
Para consultar catálogos dos dados usando o Athena, siga um destes procedimentos.
+ Registre o catálogo como uma fonte de dados no Athena e use o nome da fonte de dados para consultar o catálogo. Nesse uso, as consultas a seguir são equivalentes.
```
SELECT * FROM my_data_source.my_database.my_table
```
+ Se você estiver consultando um catálogo que não tenha sido registrado como uma fonte de dados do Athena, você poderá fornecer o caminho completo para o catálogo em suas consultas do `SELECT`, como no exemplo a seguir.
```
SELECT * FROM "my_catalog/my_subcatalog".my_database.my_table
```
+ Você também poderá fazer isso via Console de gerenciamento da AWS.
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. No editor de consultas, em **Fonte de dados**, escolha **AwsDataCatalog**.
1. Em **Catálogo**, escolha o nome do catálogo que deseja usar.
1. Em **Banco de dados**, escolha o banco de dados que contém a tabela que deseja consultar.
1. Insira uma consulta como `SELECT * FROM my_table` e, em seguida, escolha **Executar**.
# Registrar um catálogo de dados de outra conta
Você pode usar o recurso de catálogo do AWS Glue entre contas do Athena para registrar um catálogo do AWS Glue de outra conta sua. Depois de configurar as permissões do IAM necessárias para o AWS Glue e registrar o catálogo como um recurso `DataCatalog` no Athena, você poderá usar o Athena para executar consultas entre contas. Para obter informações sobre como configurar as permissões necessárias, consulte [Configurar o acesso entre contas aos catálogos de dados do AWS Glue](security-iam-cross-account-glue-catalog-access.md).
O procedimento a seguir mostra como usar o Athena para configurar um AWS Glue Data Catalog em uma conta da Amazon Web Services diferente da sua fonte de dados.
## Registrar via console
1. Siga as etapas em [Configurar o acesso entre contas aos catálogos de dados do AWS Glue](security-iam-cross-account-glue-catalog-access.md) para garantir que você tenha permissões para consultar o catálogo de dados na outra conta.
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. Escolha **Fontes de dados e catálogos**.
1. No canto superior direito do console, escolha **Create data source** (Criar fonte de dados).
1. Na página **Choose a data source** (Escolher uma fonte de dados), para **Data sources** (Fontes de dados), escolha **S3 - AWS Glue Data Catalog** e escolha **Next** (Próximo).
1. Na página **Enter data source details** (Inserir os detalhes da fonte de dados), na seção **AWS Glue Data Catalog**, para **Choose an AWS Glue Data Catalog** (Escolher um AWS Glue Data Catalog), escolha **AWS Glue Data Catalog in another account** (AWS Glue Data Catalog em outra conta).
1. Em **Data source details** (Detalhes da origemdos dados), forneça as seguintes informações:
+ **Data source name** (Nome da origem dos dados): insira o nome que você deseja usar em suas consultas SQL para fazer referência ao catálogo de dados na outra conta.
+ **Description** (Descrição): insira uma descrição do catálogo de dados na outra conta (opcional).
+ **Catalog ID** (ID do catálogo): insira o ID de 12 dígitos da conta da Amazon Web Services à qual o catálogo de dados pertence. O ID da conta da Amazon Web Services é o ID do catálogo.
1. (Opcional) Para **Tags**, adicione pares de chave-valor que você queira associar com a origem dos dados. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Próximo**.
1. Na página **Review and create** (Revisar e criar), analise as informações fornecidas e selecione **Create data source** (Criar fonte de dados). A página **Data source details** (Detalhes da fonte de dados) lista os bancos de dados e etiquetas do catálogo de dados que você registrou.
1. Escolha **Fontes de dados e catálogos**. O catálogo de dados que você registrou está listado na coluna **Data source name** (Nome da fonte de dados).
1. Para visualizar ou editar as informações do catálogo de dados, escolha o catálogo e selecione **Actions** (Ações), **Edit** (Editar).
1. Para excluir o novo catálogo de dados, escolha o catálogo e selecione **Actions** (Ações) **Delete** (Excluir).
## Registrar usando operações da API
1. O corpo da seguinte solicitação `CreateDataCatalog` registra um catálogo do AWS Glue para acesso entre contas:
```
# Example CreateDataCatalog request to register a cross-account Glue catalog:
{
"Description": "Cross-account Glue catalog",
"Name": "ownerCatalog",
"Parameters": {"catalog-id" : "" # Owner's account ID
},
"Type": "GLUE"
}
```
1. O código de exemplo a seguir usa um cliente Java para criar o objeto `DataCatalog`.
```
# Sample code to create the DataCatalog through Java client
CreateDataCatalogRequest request = new CreateDataCatalogRequest()
.withName("ownerCatalog")
.withType(DataCatalogType.GLUE)
.withParameters(ImmutableMap.of("catalog-id", ""));
athenaClient.createDataCatalog(request);
```
Após essas etapas, o mutuário deverá ver *`ownerCatalog`* ao chamar a operação de API [ListDataCatalogs](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDataCatalogs.html).
## Registrar via AWS CLI
Use o seguinte exemplo de comando da CLI para registrar um AWS Glue Data Catalog de outra conta
```
aws athena create-data-catalog \
--name cross_account_catalog \
--type GLUE \
--description "Cross Account Catalog" \
--parameters catalog-id=
```
Para saber mais, consulte [Consultar entre contas AWS Glue Data Catalog usando o Amazon Athena](https://aws.amazon.com/blogs/big-data/query-cross-account-aws-glue-data-catalogs-using-amazon-athena/) no *AWS Blog Big Data*.
# Controlar o acesso a catálogos de dados com políticas do IAM
Para controlar o acesso a catálogos de dados, use as permissões do IAM no nível do recurso ou as políticas do IAM baseadas em identidade.
O procedimento a seguir é específico ao Athena.
Para obter informações específicas do IAM, acesse os links listados no fim desta seção. Para obter informações sobre políticas de catálogo de dados JSON de exemplo, consulte [Políticas de catálogo de dados de exemplo](datacatalogs-example-policies.md).
**Para usar o editor visual no console do IAM para criar uma política de catálogo de dados**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM, em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação à esquerda, escolha **Policies (Políticas)** e **Create policy (Criar política)**.
1. Na guia **Editor visual**, selecione **Escolher um serviço**. Em seguida, escolha o Athena para adicionar à política.
1. Escolha **Select actions (Selecionar ações)** e defina as ações para adicionar à política. O editor visual mostra as ações disponíveis no Athena. Para obter mais informações, consulte [Ações, recursos e chaves de condição do Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html) na *Referência de autorização do serviço*.
1. Escolha **Add actions (Adicionar ações)** para digitar uma ação específica ou use caracteres curinga (\$1) para especificar várias ações.
Por padrão, a política que você está criando permite as ações que você escolhe. Se você escolher uma ou mais ações compatíveis com as permissões no nível do recurso `datacatalog` no Athena, o editor listará o recurso `datacatalog`.
1. Escolha **Recursos** para especificar os catálogos de dados específicos para sua política. Para obter políticas de catálogo de dados JSON de exemplo, consulte [Políticas de catálogo de dados de exemplo](datacatalogs-example-policies.md).
1. Especifique o recurso `datacatalog` da seguinte forma:
```
arn:aws:athena:::datacatalog/
```
1. Selecione **Review Policy (Revisar política)**, digite um **Name (Nome)** e uma **Description (Descrição)** (opcional) para a política que você está criando. Revise o resumo da política para ter certeza de que você concedeu as permissões que pretendia.
1. Escolha **Criar política** para salvar sua nova política.
1. Anexe essa política baseada em identidade a um usuário, um grupo ou uma função e especifique os recursos do `datacatalog` que eles podem acessar.
Para obter mais informações, consulte os seguintes tópicos na *Referência de autorização do serviço* e no *Manual do usuário do IAM*:
+ [Ações, recursos e chaves de condição do Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html)
+ [Criar políticas com o editor visual](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor)
+ [Adicionar e remover políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)
+ [Controlar o acesso aos recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html#access_controlling-resources)
Para obter políticas de catálogo de dados JSON de exemplo, consulte [Políticas de catálogo de dados de exemplo](datacatalogs-example-policies.md).
Para obter informações sobre permissões do AWS Glue e permissões de crawler do AWS Glue, consulte [Configurar permissões do IAM para o AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html) e [Pré-requisitos do crawler](https://docs.aws.amazon.com/glue/latest/dg/crawler-prereqs.html) no *Guia do desenvolvedor do AWS Glue*.
Para obter uma lista completa de ações do Amazon Athena, consulte os nomes das ações de API na [Referência de API do Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).
# Políticas de catálogo de dados de exemplo
Esta seção inclui exemplos de políticas que você pode usar para habilitar várias ações nos catálogos de dados.
Um catálogo de dados é um recurso do IAM gerenciado pelo Athena. Portanto, se sua política de catálogo de dados usa ações que usam o `datacatalog` como uma entrada, especifique o ARN do catálogo de dados da seguinte maneira:
```
"Resource": [arn:aws:athena:::datacatalog/]
```
O `` é o nome do seu catálogo de dados. Por exemplo, para um catálogo de dados chamado `test_datacatalog`, especifique-o como um recurso da seguinte forma:
```
"Resource": ["arn:aws:athena:us-east-1:123456789012:datacatalog/test_datacatalog"]
```
Para obter uma lista completa de ações do Amazon Athena, consulte os nomes das ações de API na [Referência de API do Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/). Para obter mais informações sobre as políticas do IAM, consulte [Criar políticas com o editor visual](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor) no *Guia do usuário do IAM*. Para obter mais informações sobre como criar políticas do IAM para grupos de trabalho, consulte [Controlar o acesso a catálogos de dados com políticas do IAM](datacatalogs-iam-policy.md).
+ [Example Policy for Full Access to All Data Catalogs](#datacatalog-policy-full-access-to-all-data-catalogs)
+ [Example Policy for Full Access to a Specified Data Catalog](#datacatalog-policy-full-access-to-a-specified-catalog)
+ [Example Policy for Querying a Specified Data Catalog](#datacatalog-policy-querying-a-specified-data-catalog)
+ [Example Policy for Management Operations on a Specified Data Catalog](#datacatalog-policy-management-operations-on-a-specified-catalog)
+ [Example Policy for Listing Data Catalogs](#datacatalog-policy-listing-data-catalogs)
+ [Example Policy for Metadata Operations on Data Catalogs](#datacatalog-policy-metadata-operations)
**Example Exemplo de política para acesso total a todos os catálogos de dados**
A seguinte política permite acesso total a todos os recursos do catálogo de dados que podem existir na conta. Recomendamos que você use essa política para os usuários da sua conta que devem administrar e gerenciar catálogos de dados para todos os outros usuários.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"athena:*"
],
"Resource":[
"*"
]
}
]
}
```
**Example Exemplo de política para acesso total a um catálogo de dados especificado**
A seguinte política permite acesso total ao único recurso específico do catálogo de dados, denominado `datacatalogA`. Você pode usar essa política para os usuários com controle total sobre um determinado catálogo de dados.
****
```
{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[
"athena:ListDataCatalogs", "athena:ListWorkGroups", "athena:GetDatabase", "athena:ListDatabases",
"athena:ListTableMetadata", "athena:GetTableMetadata" ], "Resource":"*" }, { "Effect":"Allow",
"Action":[ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery",
"athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:StopQueryExecution",
"athena:GetQueryResultsStream", "athena:ListNamedQueries", "athena:CreateNamedQuery",
"athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution",
"athena:DeleteWorkGroup", "athena:UpdateWorkGroup", "athena:GetWorkGroup",
"athena:CreateWorkGroup" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:workgroup/*"
] }, { "Effect":"Allow", "Action":[ "athena:CreateDataCatalog", "athena:DeleteDataCatalog",
"athena:GetDataCatalog", "athena:GetDatabase", "athena:GetTableMetadata", "athena:ListDatabases",
"athena:ListTableMetadata", "athena:UpdateDataCatalog" ],
"Resource":"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
} ] }
```
**Example Exemplo de política para consulta em um catálogo de dados especificado**
Na política a seguir, um usuário tem permissão para executar consultas no especificado `datacatalogA`. O usuário não tem permissão para executar tarefas de gerenciamento para o próprio catálogo de dados, como atualizá-lo ou excluí-lo.
****
```
{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[
"athena:StartQueryExecution" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:workgroup/*"
] }, { "Effect":"Allow", "Action":[ "athena:GetDataCatalog" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
] } ] }
```
**Example Exemplo de política para operações de gerenciamento em um catálogo de dados especificado**
Na política a seguir, o usuário tem permissão para criar, excluir, obter detalhes e atualizar um catálogo de dados `datacatalogA`.
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"athena:CreateDataCatalog", "athena:GetDataCatalog", "athena:DeleteDataCatalog",
"athena:UpdateDataCatalog" ], "Resource": [
"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
] } ] }
```
**Example Exemplo de política para listagem de catálogos de dados**
A política a seguir permite que todos os usuários listem todos os catálogos de dados:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs"
],
"Resource": "*"
}
]
}
```
**Example Exemplo de política para operações de metadados em catálogos de dados**
A política a seguir permite operações de metadados em catálogos de dados:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:GetDatabase",
"athena:GetTableMetadata",
"athena:ListDatabases",
"athena:ListTableMetadata"
],
"Resource": "*"
}
]
}
```
# Usar um formulário no console do Athena para adicionar uma tabela do AWS Glue
O procedimento a seguir mostra como usar o console do Athena para adicionar uma tabela usando o formulário **Create Table From S3 bucket data** (Criar tabela a partir de bucket do S3).
**Como adicionar uma tabela e inserir informações de esquema usando um formulário**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No editor de consultas, ao lado de **Tables and views** (Tabelas e visualizações), escolha **Create** (Criar) e, em seguida, escolha **S3 bucket data** (Dados do bucket do S3).
1. No formulário **Create Table From S3 bucket data** (Criar tabela a partir de dados de bucket do S3), em **Table name** (Nome da tabela), insira um nome para a tabela. Para obter informações sobre caracteres aceitáveis em nomes de bancos de dados, nomes de tabelas e nomes de colunas no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
1. Em **Database configuration** (Configuração do banco de dados), escolha um banco de dados existente ou crie um.
1. Em **Location of Input Data Set** (Local do conjunto de dados de entrada), especifique o caminho no Amazon S3 para a pasta que contém o conjunto de dados que você deseja processar. Não inclua um nome de arquivo no caminho. O Athena verifica todos os arquivos na pasta especificada. Se seus dados já estiverem particionados (p. ex.,
s3://amzn-s3-demo-bucket/logs/year=2004/month=12/day=11/), insira somente o caminho base (por exemplo, s3://amzn-s3-demo-bucket/logs/).
1. Em **Data format** (Formato de dados), escolha entre as seguintes opções:
+ Em **Table type** (Tipo de tabela), escolha **Apache Hive**, **Apache Iceberg** ou **Delta Lake**. O Athena usa o tipo de tabela Apache Hive como padrão. Para obter informações sobre como consultar tabelas do Apache Iceberg no Athena, consulte [Consultar tabelas do Apache Iceberg](querying-iceberg.md). Para obter informações sobre como usar tabelas do Delta Lake no Athena, consulte [Consultar tabelas do Linux Foundation Delta Lake](delta-lake-tables.md).
+ Em **File format** (Formato de arquivo), escolha o formato de arquivo ou log dos seus dados.
+ Na opção **Text File with Custom Delimiters (Arquivo de texto com delimitadores personalizados)**, especifique um **Field terminator (Terminador de campo)** (ou seja, um delimitador de coluna). Opcionalmente, você pode especificar um **terminador de coleção** que marque o fim de um tipo de matriz ou um **terminador de coleção** que marque o fim de um tipo de dados de mapa.
+ **Biblioteca SerDe**: uma biblioteca SerDe (serializador-desserializador) analisa um formato de dados específico para que o Athena possa criar uma tabela para ele. Para a maioria dos formatos, uma biblioteca SerDe padrão é escolhida para você. Para os formatos a seguir, escolha uma biblioteca de acordo com seus requisitos:
+ **Apache Web Logs**: escolha a biblioteca **RegexSerDe** ou **GrokserDe**. Para RegexSerDe, forneça uma expressão regular na caixa **Regex definition** (Definição Regex). Para GrokserDe, forneça uma série de expressões regulares nomeadas para a propriedade SerDe `input.format`. As expressões regulares nomeadas são mais fáceis de ler e manter do que as expressões regulares. Para obter mais informações, consulte [Consulta de logs do Apache armazenados no Amazon S3](querying-apache-logs.md).
+ **CSV**: escolha **LazySimpleSerDe** se seus dados separados por vírgula não contiverem valores entre aspas duplas ou se usarem o formato `java.sql.Timestamp`. Escolha **OpenCSVSerDe** se os dados incluírem aspas ou usarem o formato numérico UNIX para `TIMESTAMP` (p. ex., `1564610311`). Para obter mais informações, consulte [Lazy Simple SerDe para arquivos CSV, TSV e com delimitação personalizada](lazy-simple-serde.md) e [Open CSV SerDe para processamento de CSV](csv-serde.md).
+ **JSON**: escolha a biblioteca **OpenX** ou **Hive** JSON SerDe. Os dois formatos esperam que cada documento JSON esteja em uma única linha de texto e que os campos não sejam separados por caracteres de nova linha. O OpenX SerDe oferece algumas propriedades adicionais. Para obter mais informações sobre essas propriedades, consulte [OpenX JSON SerDe](openx-json-serde.md). Para obter mais informações sobre o Hive SerDe, consulte [Hive JSON SerDe](hive-json-serde.md).
Para obter mais informações sobre como usar as bibliotecas SerDe no Athena, consulte [Escolha de um SerDe para seus dados](supported-serdes.md).
1. Em **SerDe properties** (Propriedades de SerDe), adicione, edite ou remova propriedades e valores de acordo com a biblioteca SerDe que você estiver usando e seus requisitos.
+ Para adicionar uma propriedade SerDe, escolha **Add SerDe property** (Adicionar propriedade SerDe).
+ No campo **Name** (Nome), insira o nome da propriedade.
+ No campo **Value** (Valor), insira um valor para a propriedade.
+ Para remover uma propriedade SerDe, escolha **Remove** (Remover).
1. Em **Table properties** (Propriedades da tabela), escolha ou edite as propriedades da tabela de acordo com seus requisitos.
+ Em **Propriedades da tabela** (Compactação de gravação), escolha uma opção de compactação. A disponibilidade da opção de compactação de gravação e das opções de compactação disponíveis depende do formato dos dados. Para obter mais informações, consulte [Usar compactação no Athena](compression-formats.md).
+ Para **Encryption** (Criptografia), selecione **Encrypted data set** (Conjunto de dados criptografados) se os dados subjacentes estiverem criptografados no Amazon S3. Essa opção define a propriedade `has_encrypted_data` da tabela como verdadeira na instrução `CREATE TABLE`.
1. Em **Column details** (Detalhes da coluna), insira os nomes e os tipos de dados das colunas que você deseja adicionar à tabela.
+ Para adicionar mais colunas uma de cada vez, escolha **Add a column (Adicionar uma coluna)**.
+ Para adicionar rapidamente mais colunas, escolha **Bulk add columns (Adicionar colunas em massa)**. Na caixa de texto, insira uma lista separada por vírgulas de colunas no formato *column\$1name* *data\$1type*, *column\$1name* *data\$1type*[, …] e escolha **Add** (Adicionar).
1. (Opcional) Em **Partition details** (Detalhes da partição), adicione um ou mais nomes de colunas e tipos de dados. O particionamento mantém os dados relacionados juntos com base nos valores das colunas e pode ajudar a reduzir a quantidade de dados digitalizados por consulta. Para obter informações sobre particionamento, consulte [Particionar dados](partitions.md).
1. (Opcional) Em **Bucketing**, você pode especificar uma ou mais colunas que tenham linhas que você deseja agrupar e, em seguida, colocar essas linhas em vários buckets. Isso permite que você consulte somente o bucket que deseja ler quando o valor das colunas agrupadas for especificado.
+ Para **Buckets**, selecione uma ou mais colunas que tenham um grande número de valores exclusivos (p. ex., uma chave primária) e que sejam frequentemente usadas para filtrar os dados em suas consultas.
+ Em **Number of buckets** (Número de buckets), insira um número que permita que os arquivos tenham o tamanho ideal. Para obter mais informações, consulte [Top 10 Performance Tuning Tips for Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) (As 10 melhores dicas para ajustar o desempenho do Amazon Athena) no AWS Big Data Blog.
+ Para especificar suas colunas agrupadas, a instrução `CREATE TABLE` usará a seguinte sintaxe:
```
CLUSTERED BY (bucketed_columns) INTO number_of_buckets BUCKETS
```
**nota**
A opção **Bucketing** (Agregar em bucket) não está disponível para o tipo de tabela do **Iceberg**.
1. A caixa **Preview table query** (Previsualizar consulta da tabela) mostra a instrução `CREATE TABLE` gerada pelas informações inseridas no formulário. A instrução de visualização não pode ser editada diretamente. Para alterar a instrução, modifique os campos no formulário acima da visualização ou [crie a instrução diretamente](creating-tables-how-to.md#to-create-a-table-using-hive-ddl) no editor de consultas em vez de usar o formulário.
1. Selecione **Create table** (Criar tabela) para executar a instrução gerada no editor de consultas e criar a tabela.
# Usar um crawler para adicionar uma tabela
Os crawlers do AWS Glue ajudam a descobrir o esquema para conjuntos de dados e registrá-los no catálogo de dados do AWS Glue. Os crawlers passam pelos dados e determinam o esquema. Além disso, o crawler pode detectar e registrar partições. Para obter mais informações, consulte [Definir crawlers](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) no *Guia do desenvolvedor do AWS Glue*. Tabelas de dados que foram rastreadas com sucesso podem ser consultadas no Athena.
**nota**
O Athena não reconhece os [padrões de exclusão](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) que você especifica para um crawler do AWS Glue. Por exemplo, se você tem um bucket do Amazon S3 com os arquivos `.csv` e `.json` e exclui os arquivos `.json` do crawler, o Athena consulta os dois grupos de arquivos. Para evitar isso, coloque os arquivos que você deseja excluir em um local diferente.
## Criar um crawler do AWS Glue
É possível criar um crawler começando no console do Athena e usando o console do AWS Glue de forma integrada. Ao criar o crawler, você especifica um local de dados no Amazon S3 para crawling.
**Para criar um crawler no AWS Glue começando do console do Athena**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No editor de consultas, ao lado de **Tabelas e visualizações**, escolha **Criar** e, em seguida, selecione **Crawler do AWS Glue**.
1. No console do **AWS Glue**, na página **Add crawler (Adicionar crawler)**, siga as etapas para criar um crawler. Para obter mais informações, consulte [Usar crawlers do AWS Glue](#schema-crawlers) neste guia e [Como preencher o AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/populate-catalog-methods.html) no *Guia do desenvolvedor do AWS Glue*.
**nota**
O Athena não reconhece os [padrões de exclusão](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) que você especifica para um crawler do AWS Glue. Por exemplo, se você tem um bucket do Amazon S3 com os arquivos `.csv` e `.json` e exclui os arquivos `.json` do crawler, o Athena consulta os dois grupos de arquivos. Para evitar isso, coloque os arquivos que você deseja excluir em um local diferente.
Depois de um rastreamento, o crawler do AWS Glue atribui automaticamente determinados metadados para ajudar a torná-los compatíveis com outras tecnologias externas, como Apache Hive, Presto e Spark. Às vezes, o crawler pode atribuir incorretamente propriedades de metadados. Corrija manualmente as propriedades no AWS Glue antes de consultar a tabela usando o Athena. Para obter mais informações, consulte [Exibir e editar detalhes da tabela](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) no *Guia do desenvolvedor do AWS Glue*.
O AWS Glue pode atribuir indevidamente metadados quando um arquivo CSV tem aspas em torno de cada campo de dados, processando a propriedade `serializationLib` incorretamente. Para obter mais informações, consulte [Lidar com dados CSV entre aspas](schema-csv.md#schema-csv-quotes).
# Usar várias fontes de dados com crawlers
Quando um crawler do AWS Glue verifica o Amazon S3 e detecta vários diretórios, ele usa uma heurística para determinar onde a raiz de uma tabela está na estrutura do diretório e quais diretórios são partições da tabela. Em alguns casos, quando o esquema detectado em dois ou mais diretórios é semelhante, o crawler pode tratá-lo como partições, em vez de tabelas à parte. Uma maneira de ajudar o crawler a descobrir tabelas individuais é adicionar o diretório raiz de cada tabela como um armazenamento de dados para o crawler.
As seguintes partições no Amazon S3 são um exemplo:
```
s3://amzn-s3-demo-bucket/folder1/table1/partition1/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition2/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition3/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition4/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition5/file.txt
```
Se o esquema de `table1` e `table2` for semelhante, e uma única origem dos dados for definida como `s3://amzn-s3-demo-bucket/folder1/` no AWS Glue, o crawler poderá criar uma única tabela com duas colunas de partição: uma com `table1` e `table2` e outra com `partition1` a `partition5`.
Para fazer com que o crawler do AWS Glue crie duas tabelas separadas, defina o crawler para ter duas fontes de dados, `s3://amzn-s3-demo-bucket/folder1/table1/` e `s3://amzn-s3-demo-bucket/folder1/table2`, conforme mostrado no procedimento a seguir.
**Para adicionar um armazenamento de dados do S3 a um crawler existente no AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, escolha **Rastreadores**.
1. Escolha o link para o seu crawler e, em seguida, escolha **Edit** (Editar).
1. Em **Step 2: Choose data sources and classifiers** (Etapa 2: Escolher fontes de dados e classificadores), escolha **Edit**(Editar).
1. Em **Fontes de dados e catálogos**, escolha **Adicionar uma fonte de dados**.
1. Na caixa de diálogo **Add data source** (Adicionar fonte de dados), em **S3 path** (Caminho do S3), escolha **Browse** (Procurar).
1. Escolha o bucket que deseja usar e, em seguida, escolha **Choose** (Escolher).
A fonte de dados que você adicionou aparece na lista **Data sources** (Fontes de dados).
1. Escolha **Próximo**.
1. Na página **Configure security settings** (Definir configurações de segurança), crie ou escolha um perfil do IAM para o crawler e, em seguida, escolha **Next** (Próximo).
1. Certifique-se de que o caminho do S3 termine em uma barra à direita e, em seguida, escolha **Add an S3 data source** (Adicionar uma fonte de dados do S3).
1. Na página **Set output and scheduling** (Definir saída e programação), em **Output configuration** (Configuração da saída), escolha o banco de dados de destino.
1. Escolha **Avançar**.
1. Na página **Review and update** (Revisar e atualizar), revise as escolhas feitas. Para editar uma etapa, escolha **Edit** (Editar).
1. Selecione **Atualizar**.
# Agendar um crawler para manter a sincronização entre o AWS Glue Data Catalog e o Amazon S3
AWS GlueOs crawlers do podem ser configurados para serem executados em uma programação ou sob demanda. Para obter mais informações, consulte [Programações baseadas em hora para trabalhos e crawlers](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html) no *Guia do desenvolvedor do AWS Glue*.
Se você tiver dados que chegam a uma tabela particionada em um horário fixo, poderá configurar um crawler do AWS Glue para ser executado de acordo com a programação para detectar e atualizar as partições da tabela. Isso pode eliminar a necessidade de executar um comando `MSCK REPAIR` possivelmente longo e caro ou executar manualmente um comando `ALTER TABLE ADD PARTITION`. Para obter mais informações, consulte [Partições de tabela](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) no *Guia do desenvolvedor do AWS Glue*.
# Otimizar consultas com indexação e filtragem de partições do AWS Glue
Quando o Athena consulta tabelas particionadas, ele recupera e filtra as partições de tabela disponíveis para o subconjunto relevante para a sua consulta. À medida que novos dados e partições são adicionados, mais tempo torna-se necessário para processar as partições, e o runtime da consulta pode aumentar. Se você tiver uma tabela com um grande número de partições que aumenta ao longo do tempo, considere o uso de indexação e filtragem de partições do AWS Glue. A indexação de partições permite que o Athena otimize o processamento das partições e melhore a performance das consulta em tabelas altamente particionadas. A configuração da filtragem de partições nas propriedades de uma tabela é um processo de duas etapas:
1. Criar um índice de partição em AWS Glue.
1. Habilitar a filtragem de partições para a tabela.
## Criar um índice de partição
Para conhecer as etapas da criação de um índice de partição no AWS Glue, consulte [Trabalhar com índices de partição](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) no Guia do desenvolvedor do AWS Glue. Para saber quais são as limitações dos índices de partição no AWS Glue, consulte a seção [Sobre índices de partição](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html#partition-index-1) na mesma página.
## Habilitar filtragem de partição
Para habilitar a filtragem de partição para a tabela, você deve definir uma nova propriedade de tabela no AWS Glue. Para conhecer as etapas da definição de propriedades de tabela no AWS Glue, consulte a página [Configurar a projeção de partições](https://docs.aws.amazon.com/athena/latest/ug/partition-projection-setting-up.html). Quando você editar os detalhes da tabela no AWS Glue, adicione o seguinte par de chave-valor à seção **Table properties** (Propriedades de tabela):
+ Para **Key** (Chave), adicione `partition_filtering.enabled`
+ Para **Value** (Valor), adicione `true`
Você pode desabilitar a filtragem de partições nessa tabela a qualquer momento definindo o valor `partition_filtering.enabled` como `false`.
Depois de concluir as etapas acima, você pode retornar ao console do Athena para consultar os dados.
Para mais informações sobre usar a indexação e filtragem de partição, consulte [Melhorar o desempenho de consultas Amazon Athena usando índices de partição AWS Glue Data Catalog](https://aws.amazon.com/blogs/big-data/improve-amazon-athena-query-performance-using-aws-glue-data-catalog-partition-indexes/) no *Blog de Big Data da AWS*.
# Usar a AWS CLI para recriar um banco de dados do AWS Glue e suas tabelas
Não é possível renomear um banco de dados do AWS Glue diretamente, mas você pode copiar a definição, modificar a definição e usá-la para recriar o banco de dados com um nome diferente. Da mesma forma, é possível copiar as definições das tabelas do banco de dados antigo, modificar as definições e usar as definições modificadas para recriar as tabelas no novo banco de dados.
**nota**
O método apresentado não copia o particionamento da tabela.
O procedimento a seguir para o Windows pressupõe que a AWS CLI esteja configurada para saída JSON. Para alterar o formato de saída padrão na AWS CLI, execute `aws configure`.
**Para copiar um banco de dados do AWS Glue usando a AWS CLI**
1. Em um prompt de comando, execute o comando da AWS CLI a seguir para recuperar a definição do banco de dados do AWS Glue que você deseja copiar.
```
aws glue get-database --name database_name
```
Para obter mais informações sobre o comando `get-database`, consulte [get-database](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html).
1. Salve a saída JSON em um arquivo com o nome do novo banco de dados (por exemplo, `new_database_name.json`) na área de trabalho.
1. Abra o arquivo `new_database_name.json` em um editor de textos.
1. No arquivo JSON, execute as seguintes etapas:
1. Remova a entrada externa `{ "Database":` e a chave de fechamento correspondente `}` no final do arquivo.
1. Altere a entrada `Name` para o nome do novo banco de dados.
1. Remova o campo `CatalogId`.
1. Salve o arquivo.
1. Em um prompt de comando, execute o comando da AWS CLI a seguir para usar o arquivo de definição de banco de dados modificado para criar o banco de dados com o novo nome.
```
aws glue create-database --database-input "file://~/Desktop\new_database_name.json"
```
Para obter mais informações sobre o comando `create-database`, consulte [create-database](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-database.html). Para obter informações sobre como usar parâmetros da AWS CLI em um arquivo, consulte [Carregar os parâmetros da AWS CLI de um arquivo](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html) no *Guia do usuário da AWS Command Line Interface*.
1. Para verificar se o novo banco de dados foi criado no AWS Glue, execute o seguinte comando:
```
aws glue get-database --name new_database_name
```
Agora você está pronto para obter a definição de uma tabela que deseja copiar para o novo banco de dados, modificar a definição e usar a definição modificada para recriar a tabela no novo banco de dados. Esse procedimento não altera o nome da tabela.
**Para copiar uma tabela do AWS Glue usando a AWS CLI**
1. Em um prompt de comando, execute o seguinte comando da AWS CLI.
```
aws glue get-table --database-name database_name --name table_name
```
Para obter mais informações sobre o comando `get-table`, consulte [get-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-table.html).
1. Salve a saída JSON em um arquivo com o nome da tabela (por exemplo, *table\$1name*.json) na área de trabalho do Windows.
1. Abra o arquivo em um editor de textos.
1. No arquivo JSON, remova a entrada externa `{"Table": ` e a chave de fechamento correspondente `}` no final do arquivo.
1. No arquivo JSON, remova as seguintes entradas e os respectivos valores:
+ `DatabaseName`: esta entrada não é necessária porque o comando `create-table` da CLI usa o parâmetro `--database-name`.
+ `CreateTime`
+ `UpdateTime`
+ `CreatedBy`
+ `IsRegisteredWithLakeFormation`
+ `CatalogId`
+ `VersionId`
1. Salve o arquivo de definição da tabela.
1. Em um prompt de comando, execute o seguinte comando da AWS CLI para recriar a tabela no novo banco de dados:
```
aws glue create-table --database-name new_database_name --table-input "file://~/Desktop\table_name.json"
```
Para obter mais informações sobre o comando `create-table`, consulte [create-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-table.html).
A tabela agora aparece no novo banco de dados no AWS Glue e pode ser consultada no Athena.
1. Repita as etapas para copiar cada tabela adicional para o novo banco de dados no AWS Glue.
# Criação de tabelas para trabalhos de ETL
É possível usar o Athena para criar tabelas que o AWS Glue possa usar para trabalhos de ETL. Os trabalhos do AWS Glue usam operações de ETL. Um trabalho do AWS Glue executa um script que extrai dados de fontes, transforma os dados e os carrega em destinos. Para obter mais informações, consulte [Criação de trabalhos no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) no *Guia do desenvolvedor do AWS Glue*.
## Criar tabelas no Athena para trabalhos ETL do AWS Glue
As tabelas que você cria no Athena devem ter uma propriedade de tabela adicionada chamada `classification`, que identifica o formato dos dados. Isso permite que o AWS Glue use as tabelas para trabalhos de ETL. Os valores de classificação podem ser `avro`, `csv`, `json`, `orc`, `parquet` ou `xml`. Veja abaixo um exemplo da instrução `CREATE TABLE` no Athena:
```
CREATE EXTERNAL TABLE sampleTable (
column1 INT,
column2 INT
) STORED AS PARQUET
TBLPROPERTIES (
'classification'='parquet')
```
Se a propriedade da tabela `classification` não tiver sido adicionada quando a tabela foi criada, a propriedade poderá ser adicionada com o console do AWS Glue.
**Para adicionar a propriedade de classificação da tabela usando o console do AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação do console, escolha **Tables** (Tabelas).
1. Escolha o link da tabela que deseja editar e, em seguida, escolha **Actions** (Ações) e **Edit table** (Editar tabela).
1. Role para baixo até a seção **Table properties** (Propriedades da tabela).
1. Escolha **Adicionar**.
1. Em **Chave**, digite **classification**.
1. Em **Value** (Valor), insira um tipo de dado (por exemplo, **json**).
1. Escolha **Salvar**.
Na seção **Table details** (Detalhes da tabela), o tipo de dado que você inseriu aparece no campo **Classification** (Classificação) da tabela.
Para obter mais informações, consulte [Trabalhar com tabelas](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) no *Guia do desenvolvedor do AWS Glue*.
## Usar trabalhos de ETL para otimizar a performance da consulta
AWS GlueOs trabalhos do podem ajudar a transformar os dados em um formato que otimiza a performance das consultas no Athena. Os formatos de dados têm um grande impacto na performance e nos custos das consultas no Athena.
O AWS Glue permite a gravação nos formatos de dados Parquet e ORC. Você pode usar esse recurso para transformar seus dados para uso no Athena. Para obter mais informações sobre o uso de Parquet e ORC e outras maneiras de melhorar o desempenho no Athena, leia [Top 10 performance tuning tips for Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
**nota**
Para reduzir as chances de o Athena não conseguir ler os tipos de dados `SMALLINT` e `TINYINT` produzidos por um trabalho de ETL do AWS Glue, converta `SMALLINT` e `TINYINT` em `INT` ao criar um trabalho de ETL que converte dados para ORC.
## Automatizar trabalhos do AWS Glue para ETL
Você pode configurar trabalhos de ETL do AWS Glue para serem executados automaticamente com base em gatilhos. Esse recurso é ideal quando há dados de fora da AWS sendo enviados para um bucket do Amazon S3 em um formato inadequado para consultas no Athena. Para obter mais informações, consulte [Iniciar trabalhos do AWS Glue usando gatilhos](https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html) no *Guia do desenvolvedor do AWS Glue*.
# Trabalhar com dados CSV no AWS Glue
Esta página descreve como usar o AWS Glue para criar um esquema usando arquivos CSV com valores de dados entre aspas de cada coluna ou de arquivos CSV que incluem valores de cabeçalho.
## Lidar com dados CSV entre aspas
Imagine que você tenha um arquivo CSV com campos de dados entre aspas duplas, como no seguinte exemplo.
```
"John","Doe","123-555-1231","John said \"hello\""
"Jane","Doe","123-555-9876","Jane said \"hello\""
```
Para executar uma consulta no Athena em uma tabela criada com base em um arquivo CSV que tenha valores entre aspas, você deve modificar as propriedades da tabela no AWS Glue para usar o OpenCSVSerDe. Para obter mais informações sobre o OpenCSV SerDe, consulte [Open CSV SerDe para processamento de CSV](csv-serde.md).
**Para editar as propriedades da tabela no console do AWS Glue**
1. No painel de navegação do console do AWS Glue, escolha **Tables**.
1. Escolha o link da tabela que deseja editar e, em seguida, escolha **Actions** (Ações) e **Edit table** (Editar tabela).
1. Na página **Edit table** (Editar tabela), faça as seguintes alterações:
+ Em **Serialization lib** (Biblioteca de serialização), insira `org.apache.hadoop.hive.serde2.OpenCSVSerde`.
+ Em **Serde parameters** (Parâmetros do Serde), insira os seguintes valores para as chaves `escapeChar`, `quoteChar` e `separatorChar`:
+ Em `escapeChar`, insira uma barra invertida (**\$1**).
+ Em `quoteChar`, insira aspas duplas (**"**).
+ Em `separatorChar`, insira uma vírgula (**,**).
1. Escolha **Salvar**.
Para obter mais informações, consulte [Exibir e editar detalhes da tabela](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) no *Guia do desenvolvedor do AWS Glue*.
Você também pode atualizar as propriedades da tabela AWS Glue programaticamente. Use a operação da API AWS Glue [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) ou o comando da AWS CLI [update-table](https://docs.aws.amazon.com/cli/latest/reference/glue/update-table.html) para modificar o bloco `SerDeInfo` na definição da tabela, conforme mostrado no exemplo de JSON a seguir.
```
"SerDeInfo": {
"name": "",
"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde",
"parameters": {
"separatorChar": ","
"quoteChar": "\""
"escapeChar": "\\"
}
},
```
## Lidar com arquivos CSV com cabeçalhos
Quando você define uma tabela no Athena com uma instrução `CREATE TABLE`, pode usar a propriedade de tabela `skip.header.line.count` para ignorar os cabeçalhos nos dados CSV, conforme mostrado no exemplo a seguir.
```
...
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/csvdata_folder/';
TBLPROPERTIES ("skip.header.line.count"="1")
```
Se preferir, remova os cabeçalhos CSV com antecedência para que as informações do cabeçalho não sejam incluídas nos resultados da consulta do Athena. Uma maneira de fazer isso é usar os trabalhos do AWS Glue, que excutam o trabalho de Extract, Transform, and Load (ETL - Extração, transformação e carga). Você pode escrever scripts no AWS Glue usando uma linguagem que é uma extensão do dialeto PySpark Python. Para obter mais informações, consulte [Criação de trabalhos no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) no *Guia do desenvolvedor do AWS Glue*.
O exemplo a seguir mostra uma função em um script do AWS Glue que escreve um quadro dinâmico usando `from_options` e define a opção de formato `writeHeader` como falsa, o que remove as informações do cabeçalho:
```
glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": "s3://amzn-s3-demo-bucket/MYTABLEDATA/"}, format = "csv", format_options = {"writeHeader": False}, transformation_ctx = "datasink2")
```
# Trabalhar com dados geoespaciais no AWS Glue
AWS GlueO não oferece suporte nativo a Well-known Text (WKT – Texto bem conhecido), Well-Known Binary (WKB – Binário bem conhecido) ou outros tipos de dados PostGIS. O classificador do AWS Glue analisa dados geoespaciais e os classifica usando tipos de dados compatíveis para o formato, como `varchar` para CSV. Assim como ocorre com outras tabelas do AWS Glue, pode ser necessário atualizar as propriedades das tabelas criadas a partir de dados geoespaciais para permitir que o Athena analise esses tipos de dados no estado em que se encontram. Para obter mais informações, consulte [Usar um crawler para adicionar uma tabela](schema-crawlers.md) e [Trabalhar com dados CSV no AWS Glue](schema-csv.md). O Athena pode não ser capaz de analisar alguns tipos de dados geoespaciais em tabelas do AWS Glue no estado em que se encontram. Para obter mais informações sobre como trabalhar com dados geoespaciais no Athena, consulte [Consultar dados geoespaciais](querying-geospatial-data.md).
# Usar a consulta federada do Amazon Athena
Se você tiver dados em origens diferentes do Amazon S3, poderá usar a consulta federada do Athena para consultá-los no local ou criar pipelines para extrair os dados de várias origens e armazená-los no Amazon S3. Com a consulta federada do Athena, é possível executar consultas SQL nos dados armazenados em origens relacionais, não relacionais, de objetos e personalizadas.
O Athena usa *conectores de origem dos dados* operados no AWS Lambda para executar as consultas federadas. Um conector de origem dos dados é uma parte do código que converte entre sua origem dos dados de destino e o Athena. Pense em um conector como uma extensão do mecanismo de consulta do Athena. Os conectores de origem dos dados predefinidos do Athena foram desenvolvidos para origens de dados, como Amazon CloudWatch Logs, Amazon DynamoDB, Amazon DocumentDB e Amazon RDS, e para origens de dados relacionais compatíveis com JDBC, como MySQL e PostgreSQL, na licença do Apache 2.0. Também é possível usar o Athena Query Federation SDK para escrever conectores personalizados. Para escolher, configurar e implantar um conector de origem dos dados em sua conta, você pode usar os consoles do Athena e do Lambda ou o AWS Serverless Application Repository. Depois que implantar conectores de fonte de dados, o conector será associado a um catálogo que pode ser especificado nas consultas SQL. É possível combinar instruções SQL de vários catálogos e abranger várias fontes de dados com uma única consulta.
Quando uma consulta é enviada para uma origem dos dados, o Athena invoca o conector correspondente para identificar as partes das tabelas que precisam ser lidas, gerencia o paralelismo e envia os predicados de filtro. Com base no usuário que envia a consulta, os conectores podem fornecer ou restringir o acesso a elementos de dados específicos. Os conectores usam o Apache Seta como o formato para retornar dados solicitados em uma consulta, o que permite que os conectores sejam implementados em linguagens como C, C\$1\$1, Java, Python e Rust. Como os conectores são processados no Lambda, eles podem ser usados para acessar os dados de qualquer origem dos dados na nuvem ou on-premises que seja acessível pelo Lambda.
Para escrever o próprio conector de origem dos dados, você pode usar o Athena Query Federation SDK para personalizar um dos conectores predefinidos disponíveis e mantidos pelo Amazon Athena. Você pode modificar uma cópia do código-fonte do [repositório do GitHub](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors) e usar a [ferramenta de publicação do conector](https://github.com/awslabs/aws-athena-query-federation/wiki/Connector_Publish_Tool) para criar seu próprio pacote do AWS Serverless Application Repository.
**nota**
Desenvolvedores de terceiro podem ter usado o Athena Query Federation SDK para escrever conectores de origem dos dados. Para problemas de suporte ou licenciamento com esses conectores de origem dos dados, entre em contato com o provedor dos conectores. Esses conectores não foram testados nem contam com suporte da AWS.
Para obter uma lista de conectores de origem dos dados escritos e testados pelo Athena, consulte [Conectores de fonte de dados disponíveis](connectors-available.md).
Para obter informações sobre como gravar o próprio conector de origem de dados, consulte [Example Athena connector](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-example) (Exemplo de conector do Athena) no GitHub.
## Considerações e limitações
+ **Versões do mecanismo**: a consulta federada do Athena é permitida apenas no mecanismo Athena versão 2 e posterior. Para obter informações sobre as versões do mecanismo do Athena, consulte [Versionamento do mecanismo do Athena](engine-versions.md).
+ **Visualizações**: é possível criar e consultar visualizações em fontes de dados federadas. As visualizações federadas são armazenadas no AWS Glue, não na fonte de dados subjacente. Para obter mais informações, consulte [Consultar visualizações federadas](running-federated-queries.md#running-federated-queries-federated-views).
+ **Identificadores delimitados**: os identificadores delimitados (também conhecidos como identificadores citados) começam e terminam com aspas ("). Atualmente, não há compatibilidade com identificadores delimitados para consultas federadas no Athena.
+ **Operações de gravação**: operações de gravação como [INSERT INTO](insert-into.md) não são suportadas. Tentar fazer isso pode gerar a mensagem de erro: This operation is currently not supported for external catalogs (Atualmente, esta operação não é suportada para catálogos externos).
+ **Preço**: para obter informações de preço, consulte [Preços do Amazon Athena](https://aws.amazon.com/athena/pricing/).
+ **Driver JDBC**: para usar o driver JDBC com consultas federadas ou um [metastore externo do Hive](connect-to-data-source-hive.md), inclua `MetadataRetrievalMethod=ProxyAPI` na string de conexão JDBC. Para obter informações sobre o driver JDBC, consulte [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md).
+ **Secrets Manager**: para usar o recurso de consulta federada do Athena com AWS Secrets Manager, você deve configurar um endpoint privado do Amazon VPC para o Secrets Manager. Para obter mais informações, consulte [Criação de um endpoint privado da VPC para o Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) no *Guia do usuário do AWS Secrets Manager*.
## Permissões obrigatórias
Conectores de fonte de dados podem exigir acesso aos recursos a seguir para funcionar corretamente. Se você usar um conector predefinido, verifique as informações do conector para garantir que tenha configurado sua VPC corretamente. Além disso, garanta que os principais do IAM que executam consultas e criam conectores tenham os privilégios para as ações necessárias. Para obter mais informações, consulte [Permitir acesso a consultas federadas do Athena: exemplos de política](federated-query-iam-access.md).
+ **Amazon S3**: além de gravar os resultados das consultas no local específico do Athena no Amazon S3, os conectores de dados gravam em um bucket de vazamento no Amazon S3. São necessárias conectividade e permissões para esse local do Amazon S3. Recomendamos usar a criptografia de derramamento para disco para cada conector e a [configuração do ciclo de vida do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) para expirar dados derramados que não sejam mais necessários.
+ **Athena**: as origens de dados precisam de conectividade com o Athena e vice-versa para conferir o status da consulta e evitar a verificação em excesso.
+ **AWS Glue Data Catalog** – conectividade e permissões serão necessárias se o conector usar o Catálogo de dados para metadados complementares ou primários.
+ **Amazon ECR** — As funções do Lambda do conector de fonte de dados usam uma imagem do Amazon ECR de um repositório Amazon ECR. O usuário que implanta o conector deve ter as permissões `ecr:BatchGetImage` e `ecr:GetDownloadUrlForLayer`. Para obter mais informações, consulte [Permissões do Amazon ECR](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#gettingstarted-images-permissions) no *Guia do desenvolvedor do AWS Lambda*.
## Vídeos
Assista aos vídeos a seguir para saber mais como usar a consulta federada do Athena.
**Vídeo: analisar os resultados da consulta federada do Amazon Athena no Quick**
O vídeo a seguir demonstra como analisar os resultados de uma consulta federada do Athena no Quick.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/HyM5d0TmwAQ)
**Vídeo: Game Analytics Pipeline**
O vídeo a seguir mostra como implantar um pipeline de dados escalável sem servidor para ingerir, armazenar e analisar dados de telemetria de jogos e serviços usando as consultas federadas do Amazon Athena.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/xcS-flUMVbs)
# Conectores de fonte de dados disponíveis
Esta seção lista os conectores de origem dos dados predefinidos do Athena que podem ser usados para consultar uma variedade de origens de dados externas ao Amazon S3. Para usar um conector em suas consultas do Athena, configure-o e implante-o em sua conta.
## Considerações e limitações
+ Alguns conectores pré-construídos exigem que você crie uma VPC e um grupo de segurança antes de poder usar o conector. Para obter informações sobre como criar VPCs, consulte (Criar uma VPC para um conector de origem de dados) [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
+ Para usar o recurso de consulta federada do Athena com o AWS Secrets Manager, configure um endpoint privado do Amazon VPC para o Secrets Manager. Para obter mais informações, consulte [Criação de um endpoint privado da VPC para o Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) no *Guia do usuário do AWS Secrets Manager*.
+ Para conectores não compatíveis com passagem direta de predicados, as consultas que incluírem um predicado vão demorar mais para serem executadas. Para conjuntos de dados pequenos, muito poucos dados são examinados, e as consultas levam em média cerca de 2 minutos. No entanto, para grandes conjuntos de dados, muitas consultas podem expirar.
+ Algumas fontes de dados federadas usam terminologia para fazer referência a objetos de dados que são diferentes do Athena. Para obter mais informações, consulte [Noções básicas de qualificadores de nomes de tabelas federadas](tables-qualifiers.md).
+ Atualizamos nossos conectores periodicamente com base nas atualizações do banco de dados ou do provedor da fonte de dados. Não oferecemos suporte a fontes de dados que estejam em fim de vida útil.
+ Para conectores que não oferecem suporte à paginação ao listar tabelas, o serviço Web poderá atingir o tempo limite se o banco de dados tiver muitas tabelas e muitos metadados. Os seguintes conectores fornecem suporte à paginação para tabelas de listagem:
+ DocumentDB
+ DynamoDB
+ MySQL
+ OpenSearch
+ Oracle
+ PostgreSQL
+ Redshift
+ SQL Server
## Modos de resolução de maiúsculas e minúsculas no SDK do Federation
O SDK do Federation é compatível com os seguintes modos padronizados de resolução de maiúsculas e minúsculas em nomes de esquemas e tabelas:
+ `NONE`: não altera maiúsculas e minúsculas nos nomes de esquemas e tabelas fornecidos.
+ `LOWER`: converte em minúsculas todos os nomes de esquemas e tabelas fornecidos.
+ `UPPER`: converte em maiúsculas todos os nomes de esquemas e tabela fornecidos.
+ `ANNOTATION`: esse modo é mantido apenas para compatibilidade com as versões anteriores e é compatível exclusivamente com os conectores do Snowflake e SAP HANA existentes.
+ `CASE_INSENSITIVE_SEARCH`: realiza pesquisas que não diferenciam maiúsculas de minúsculas em nomes de esquemas e tabelas.
## Compatibilidade com conectores para modos de resolução de maiúsculas e minúsculas
### Compatibilidade com o modo básico
Todos os conectores JDBC são compatíveis com os seguintes modos básicos:
+ `NONE`
+ `LOWER`
+ `UPPER`
### Compatibilidade com o modo de anotação
Apenas os seguintes conectores são compatíveis com o modo `ANNOTATION`:
+ Snowflake
+ SAP HANA
**nota**
É recomendável usar CASE\$1INSENSITIVE\$1SEARCH em vez de ANNOTATION.
### Compatibilidade com pesquisas que não diferenciam maiúsculas de minúsculas
Os seguintes conectores são compatíveis com `CASE_INSENSITIVE_SEARCH`:
+ DataLake Gen2
+ Snowflake
+ Oracle
+ Synapse
+ MySQL
+ PostgreSQL
+ Redshift
+ ClickHouse
+ SQL Server
+ DB2
## Limitações da resolução de maiúsculas e minúsculas
Lembre-se das seguintes limitações ao usar modos de resolução de maiúsculas e minúsculas:
+ Ao usar o modo `LOWER`, o nome do esquema e todas as tabelas do esquema devem ser escritos em minúsculas.
+ Ao usar o modo `UPPER`, o nome do esquema e todas as tabelas do esquema devem ser escritos em maiúsculas.
+ Ao usar um `CASE_INSENSITIVE_SEARCH`:
+ Os nomes de esquemas devem ser exclusivos
+ Os nomes das tabelas de um esquema devem ser exclusivos (por exemplo, você não pode ter "Apple" e "APPLE")
+ Limitações da integração do Glue:
+ O Glue é compatível apenas com nomes em minúsculas
+ Somente os modos `NONE` ou `LOWER` funcionarão ao registrar a função do Lambda com o GlueDataCatalog/LakeFormation
## Mais informações
+ Para obter informações sobre como implantar um conector de origem dos dados do Athena, consulte [Usar a consulta federada do Amazon Athena](federated-queries.md).
+ Para obter informações sobre consultas que usam conectores de fonte de dados do Athena, consulte [Executar consultas federadas](running-federated-queries.md).
**Topics**
+ [Considerações e limitações](#connectors-available-considerations)
+ [Modos de resolução de maiúsculas e minúsculas no SDK do Federation](#case-resolver-modes)
+ [Compatibilidade com conectores para modos de resolução de maiúsculas e minúsculas](#connector-support-matrix)
+ [Limitações da resolução de maiúsculas e minúsculas](#case-resolver-limitations)
+ [Mais informações](#connectors-available-additional-resources)
+ [Azure Data Lake Storage](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [Cloudera Hive](connectors-cloudera-hive.md)
+ [Cloudera Impala](connectors-cloudera-impala.md)
+ [CloudWatch](connectors-cloudwatch.md)
+ [métricas do CloudWatch](connectors-cwmetrics.md)
+ [CMDB](connectors-cmdb.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [Google BigQuery](connectors-bigquery.md)
+ [Google Cloud Storage](connectors-gcs.md)
+ [HBase](connectors-hbase.md)
+ [Hortonworks](connectors-hortonworks.md)
+ [Kafka](connectors-kafka.md)
+ [MSK](connectors-msk.md)
+ [MySQL](connectors-mysql.md)
+ [Neptune](connectors-neptune.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redis OSS](connectors-redis.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [SQL Server](connectors-microsoft-sql-server.md)
+ [Teradata](connectors-teradata.md)
+ [Timestream](connectors-timestream.md)
+ [TPC-DS](connectors-tpcds.md)
+ [Vertica](connectors-vertica.md)
**nota**
O [AthenaJdbcConnector](https://serverlessrepo.aws.amazon.com/applications/us-east-1/292517598671/AthenaJdbcConnector) (versão mais recente 2022.4.1) foi descontinuado. Ao invés dele, use um conector específico para banco de dados como aqueles para [MySQL](connectors-mysql.md), [Redshift](connectors-redshift.md) ou [PostgreSQL](connectors-postgresql.md).
# Conector do Amazon Athena para o Azure Data Lake Storage (ADLS) Gen2
O conector do Amazon Athena para o [Azure Data Lake Storage (ADLS) Gen2](https://docs.microsoft.com/en-us/azure/databricks/data/data-sources/azure/adls-gen2/) permite que o Amazon Athena execute consultas SQL em dados armazenados no ADLS. O Athena não pode acessar diretamente os arquivos armazenados no data lake.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
+ **Fluxo de trabalho** – O conector implementa a interface JDBC, que usa o driver `com.microsoft.sqlserver.jdbc.SQLServerDriver`. O conector envia consultas para o mecanismo do Azure Synapse, que então acessa o data lake.
+ **Manipulação de dados e S3** – Normalmente, o conector Lambda consulta dados diretamente sem transferência para o Amazon S3. No entanto, quando os dados retornados pela função Lambda excedem os limites do Lambda, os dados são gravados no bucket de vazamento do Amazon S3 que você especifica para que o Athena possa ler o excesso.
+ **Autenticação AAD** – O AAD pode ser usado como um método de autenticação para o conector Azure Synapse. Para usar o AAD, a string de conexão JDBC usada pelo conector deve conter os parâmetros de URL `authentication=ActiveDirectoryServicePrincipal`, `AADSecurePrincipalId` e`AADSecurePrincipalSecret`. Esses parâmetros podem ser passados diretamente ou pelo Secrets Manager.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados date e timestamp para os tipos de dados apropriados.
## Termos
Os termos a seguir são relativos ao conector do Azure Data Lake Storage Gen2.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Azure Data Lake Storage Gen2.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Azure Data Lake Storage Gen2 usando um objeto de conexões do Glue. Para isso, defina a variável de ambiente `glue_connection` do conector do Azure Data Lake Storage Gen2 como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type DATALAKEGEN2
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Azure Data Lake Storage Gen2 criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Azure Data Lake Storage Gen2 criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
datalakegentwo://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | DataLakeGen2MuxCompositeHandler |
| Manipulador de metadados | DataLakeGen2MuxMetadataHandler |
| Manipulador de registros | DataLakeGen2MuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mydatalakegentwocatalog, então o nome da variável de ambiente será mydatalakegentwocatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do DataLakeGen2 que ofereça suporte a duas instâncias de banco de dados: `datalakegentwo1` (o padrão) e `datalakegentwo2`.
****
| Propriedade | Valor |
| --- | --- |
| default | datalakegentwo://jdbc:sqlserver://adlsgentwo1.hostname:port;databaseName=database\$1name;\$1\$1secret1\$1name\$1 |
| datalakegentwo\$1catalog1\$1connection\$1string | datalakegentwo://jdbc:sqlserver://adlsgentwo1.hostname:port;databaseName=database\$1name;\$1\$1secret1\$1name\$1 |
| datalakegentwo\$1catalog2\$1connection\$1string | datalakegentwo://jdbc:sqlserver://adlsgentwo2.hostname:port;databaseName=database\$1name;\$1\$1secret2\$1name\$1 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${secret1_name}`.
```
datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=database_name;${secret1_name}
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=database_name;user=user_name;password=password
```
#### Uso de um único manipulador de conexão
É possível usar os seguintes manipuladores de metadados e registros de conexão única para se conectar a uma única instância do Azure Data Lake Storage Gen2.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | DataLakeGen2CompositeHandler |
| Manipulador de metadados | DataLakeGen2MetadataHandler |
| Manipulador de registros | DataLakeGen2RecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Azure Data Lake Storage Gen2 compatível com uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do ADLS Gen2 e do Arrow.
****
| ADLS Gen2 | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| date | Date(DAY) |
| horário | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
## Partições e divisões
O Azure Data Lake Storage Gen2 usa armazenamento de blobs Gen2 compatível com Hadoop para armazenar arquivos de dados. Os dados desses arquivos são consultados no mecanismo do Azure Synapse. O mecanismo Azure Synapse trata os dados do Gen2 armazenados nos sistemas de arquivos como tabelas externas. As partições são implementadas com base no tipo de dados. Se os dados já tiverem sido particionados e distribuídos no sistema de armazenamento do Gen2, o conector recuperará os dados como uma única divisão.
## desempenho
O conector do Azure Data Lake Storage Gen2 apresenta uma performance de consulta mais lenta quando executa várias consultas ao mesmo tempo e está sujeito a controle de utilização.
O conector do Athena para o Azure Data Lake Storage Gen2 realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. Predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Azure Data Lake Storage Gen2 pode combinar essas expressões e passá-las diretamente ao Azure Data Lake Storage Gen2 para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Azure Data Lake Storage Gen2 são compatíveis com passagem de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade:**EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Consultas de passagem
O conector do Azure Data Lake Storage Gen2 é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Azure Data Lake Storage Gen2, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Azure Data Lake Storage Gen2. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre versões do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/pom.xml) do conector do Azure Data Lake Storage Gen2 em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-datalakegen2) em GitHub.com.
# Conector do Amazon Athena para o Azure Synapse
O conector do Amazon Athena para o [Azure Synapse Analytics](https://docs.microsoft.com/en-us/azure/synapse-analytics/overview-what-is) permite que o Amazon Athena execute consultas SQL em seus bancos de dados do Azure Synapse usando JDBC.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados `Date` e `Timestamp` para o tipo de dados apropriado.
+ Para pesquisar valores negativos dos tipos `Real` e `Float`, use o operador `<=` ou `>=`.
+ Não há suporte para os tipos de dados `binary`, `varbinary`, `image` e `rowversion`.
## Termos
Os termos a seguir estão relacionados ao conector Synapse.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Synapse.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Synapse usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Synapse como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type SYNAPSE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Synapse criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Synapse criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas (recomendadas)
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
synapse://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | SynapseMuxCompositeHandler |
| Manipulador de metadados | SynapseMuxMetadataHandler |
| Manipulador de registros | SynapseMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mysynapsecatalog, então o nome da variável de ambiente será mysynapsecatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Synapse que ofereça suporte a duas instâncias de banco de dados: `synapse1` (o padrão) e `synapse2`.
****
| Propriedade | Valor |
| --- | --- |
| default | synapse://jdbc:synapse://synapse1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| synapse\$1catalog1\$1connection\$1string | synapse://jdbc:synapse://synapse1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| synapse\$1catalog2\$1connection\$1string | synapse://jdbc:synapse://synapse2.hostname:port;databaseName=;\$1\$1secret2\$1name\$1 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome do segredo \$1\$1secret\$1name\$1.
```
synapse://jdbc:synapse://hostname:port;databaseName=;${secret_name}
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
synapse://jdbc:synapse://hostname:port;databaseName=;user=;password=
```
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Synapse.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | SynapseCompositeHandler |
| Manipulador de metadados | SynapseMetadataHandler |
| Manipulador de registros | SynapseRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Synapse com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | synapse://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Autenticação da Configuração do Active Directory
O conector Amazon Athena Azure Synapse oferece suporte à Autenticação do Microsoft Active Directory. Antes de começar, você deve configurar um usuário administrativo no portal do Microsoft Azure e usá-lo AWS Secrets Manager para criar um segredo.
**Para configurar o usuário administrativo do Active Directory:**
1. Usando uma conta que tenha privilégios administrativos, faça login no portal Microsoft Azure em [https://portal.azure.com/](https://portal.azure.com/).
1. Na caixa de pesquisa, insira **Azure Synapse Analytics** e escolha **Azure Synapse** Analytics.
![\[Escolha Azure Synapse Analytics.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-azure-synapse-1.png)
1. Abra o menu à esquerda.
![\[Escolha o menu do portal do Azure.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-azure-synapse-2.png)
1. No painel de navegação, escolha **Azure Active Directory**.
1. Na guia **Definir administrador**, defina o **administrador do Active Directory** como um usuário novo ou existente.
![\[Use a guia Definir administrador\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-azure-synapse-3.png)
1. Em AWS Secrets Manager, armazene as credenciais de nome de usuário e senha do administrador. Para obter informações sobre como criar um segredo no Secrets Manager, consulte [Criação de um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
**Para visualizar o segredo no Secrets Manager**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. No painel de navegação, escolha **Secrets** (Segredos).
1. Na página **Secrets** (Segredos), selecione o link do seu segredo.
1. Na página de detalhes do seu segredo, escolha **Retrieve secret value** (Recuperar valor do segredo).
![\[Visualizando segredos em AWS Secrets Manager.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-azure-synapse-4.png)
##### Modificando a string de conexão
Para habilitar a Autenticação do Active Directory para o conector, modifique a string de conexão usando a seguinte sintaxe:
```
synapse://jdbc:synapse://hostname:port;databaseName=database_name;authentication=ActiveDirectoryPassword;{secret_name}
```
##### Usando o ActiveDirectoryServicePrincipal
O conector do Amazon Athena para o Azure Synapse também oferece suporte ao `ActiveDirectoryServicePrincipal`. Para habilitar isso, modifique a string de conexão da seguinte forma:
```
synapse://jdbc:synapse://hostname:port;databaseName=database_name;authentication=ActiveDirectoryServicePrincipal;{secret_name}
```
Para `secret_name`, especifique o ID do aplicativo ou cliente como o nome de usuário e o segredo de uma identidade de serviço principal como a senha.
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os tipos de dados correspondentes para Synapse e Apache Arrow.
****
| Synapse | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| date | Date(DAY) |
| horário | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
| nchar[n] | VARCHAR |
| nvarchar[n/max] | VARCHAR |
## Partições e divisões
Uma partição é representada por uma única coluna de partição do tipo `varchar`. O Synapse oferece suporte a particionamento por intervalo, portanto, o particionamento é implementado extraindo a coluna da partição e o intervalo da partição das tabelas de metadados do Synapse. Esses valores de intervalo são usados para criar as divisões.
## desempenho
A seleção de um subconjunto de colunas diminui significativamente o runtime da consulta. O conector apresenta um controle de utilização significativo devido à simultaneidade.
O conector do Athena para o Synapse realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. Predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Synapse pode combinar essas expressões e passá-las diretamente ao Synapse para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Synapse são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade:**EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Consultas de passagem
O conector Synapse é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Synapse, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Synapse. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/LICENSE.txt) em GitHub.com.
## Recursos adicionais
+ Para ver um artigo que mostra como usar o Quick e a consulta federada Amazon Athena para criar painéis e visualizações em dados armazenados nos bancos de dados do Microsoft Azure Synapse, consulte [Perform multi-cloud analytics using Quick, Amazon Athena Federated Query, and Microsoft Azure Synapsee](https://aws.amazon.com/blogs/business-intelligence/perform-multi-cloud-analytics-using-amazon-quicksight-amazon-athena-federated-query-and-microsoft-azure-synapse/) em *AWS Big Data Blog*.
+ Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/pom.xml) do conector Synapse em GitHub.com.
+ Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-synapse) em GitHub.com.
# Conector do Amazon Athena para o Cloudera Hive
O conector do Amazon Athena para o Cloudera Hive permite que o Athena execute consultas SQL na distribuição Hadoop do [Cloudera Hive](https://www.cloudera.com/products/open-source/apache-hadoop/apache-hive.html). O conector transforma suas consultas SQL do Athena na sintaxe equivalente do HiveQL.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
## Termos
Os termos a seguir estão relacionados ao conector Cloudera Hive.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Cloudera Hive.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Cloudera Hive usando um objeto de conexões do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Cloudera Hive como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type CLOUDERAHIVE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Cloudera Hive criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Cloudera Hive criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
hive://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | HiveMuxCompositeHandler |
| Manipulador de metadados | HiveMuxMetadataHandler |
| Manipulador de registros | HiveMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myhivecatalog, então o nome da variável de ambiente será myhivecatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Hive que ofereça suporte a duas instâncias de banco de dados: `hive1` (o padrão) e `hive2`.
****
| Propriedade | Valor |
| --- | --- |
| default | hive://jdbc:hive2://hive1:10000/default;\$1\$1Test/RDS/hive1\$1 |
| hive2\$1catalog1\$1connection\$1string | hive://jdbc:hive2://hive1:10000/default;\$1\$1Test/RDS/hive1\$1 |
| hive2\$1catalog2\$1connection\$1string | hive://jdbc:hive2://hive2:10000/default;UID=sample&PWD=sample |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string da conexão JDBC, o conector Cloudera Hive exige um segredo do AWS Secrets Manager. Para usar o recurso de consulta federada do Athena com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
Coloque o nome de um segredo do AWS Secrets Manager na string da conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/hive1}`.
```
hive://jdbc:hive2://hive1:10000/default;...&${Test/RDS/hive1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
hive://jdbc:hive2://hive1:10000/default;...&UID=sample2&PWD=sample2&...
```
Atualmente, o conector Cloudera Hive reconhece as propriedades do JDBC `UID` e `PWD`.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Cloudera Hive.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | HiveCompositeHandler |
| Manipulador de metadados | HiveMetadataHandler |
| Manipulador de registros | HiveRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Cloudera Hive com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| padrão | hive://jdbc:hive2://hive1:10000/default;secret=\$1\$1Test/RDS/hive1\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC, do Cloudera Hive e do Arrow.
****
| JDBC | Cloudera Hive | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Inteiro | TINYINT | Tiny |
| Short | SMALLINT | Smallint |
| Inteiro | INT | Int |
| Longo | BIGINT | Bigint |
| flutuação | float4 | Float4 |
| Duplo | float8 | Float8 |
| Data | date | Data/Dia |
| Timestamp | timestamp | Date Milli |
| String | VARCHAR | Varchar |
| Bytes | bytes | Varbinary |
| BigDecimal | Decimal | Decimal |
| ARRAY | N/D (ver nota) | Lista |
**nota**
Atualmente, o Cloudera Hive não oferece suporte para os tipos agregados `ARRAY`, `MAP`, `STRUCT` ou `UNIONTYPE`. As colunas de tipos agregados são tratadas como colunas `VARCHAR` pelo SQL.
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O Cloudera Hive oferece suporte a partições estáticas. O conector do Athena para o Cloudera Hive pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento estático é altamente recomendado. O conector Cloudera Hive é resiliente ao controle de utilização devido à simultaneidade.
O conector do Athena para o Cloudera Hive executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Cloudera Hive pode combinar essas expressões e passá-las diretamente ao Cloudera Hive para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Cloudera Hive são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector Cloudera Hive é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Cloudera Hive, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Cloudera Hive. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/pom.xml) do conector Cloudera Hive em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudera-hive) em GitHub.com.
# Conector do Amazon Athena para o Cloudera Impala
O conector do Amazon Athena para o Cloudera Impala permite que o Athena execute consultas SQL na distribuição do [Cloudera Impala](https://docs.cloudera.com/cdw-runtime/cloud/impala-overview/topics/impala-overview.html). O conector transforma suas consultas SQL do Athena na sintaxe equivalente do Impala.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
## Termos
Os termos a seguir estão relacionados ao conector Cloudera Impala.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Cloudera Impala.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Cloudera Impala usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector Cloudera Impala como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type CLOUDERAIMPALA
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Cloudera Impala criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Cloudera Impala criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no formato a seguir para se conectar a um cluster do Impala.
```
impala://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | ImpalaMuxCompositeHandler |
| Manipulador de metadados | ImpalaMuxMetadataHandler |
| Manipulador de registros | ImpalaMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão do cluster do Impala para um catálogo do Athena. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myimpalacatalog, então o nome da variável de ambiente será myimpalacatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Impala que ofereça suporte a duas instâncias de banco de dados: `impala1` (o padrão) e `impala2`.
****
| Propriedade | Valor |
| --- | --- |
| default | impala://jdbc:impala://some.impala.host.name:21050/?\$1\$1Test/impala1\$1 |
| impala\$1catalog1\$1connection\$1string | impala://jdbc:impala://someother.impala.host.name:21050/?\$1\$1Test/impala1\$1 |
| impala\$1catalog2\$1connection\$1string | impala://jdbc:impala://another.impala.host.name:21050/?UID=sample&PWD=sample |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/impala1host}`.
```
impala://jdbc:impala://Impala1host:21050/?...&${Test/impala1host}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
impala://jdbc:impala://Impala1host:21050/?...&UID=sample2&PWD=sample2&...
```
Atualmente, o Cloudera Impala reconhece as propriedades do JDBC `UID` e `PWD`.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Cloudera Impala.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | ImpalaCompositeHandler |
| Manipulador de metadados | ImpalaMetadataHandler |
| Manipulador de registros | ImpalaRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Cloudera Impala com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | impala://jdbc:impala://Impala1host:21050/?secret=\$1\$1Test/impala1host\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC, do Cloudera Impala e do Arrow.
****
| JDBC | Cloudera Impala | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Inteiro | TINYINT | Tiny |
| Short | SMALLINT | Smallint |
| Inteiro | INT | Int |
| Longo | BIGINT | Bigint |
| flutuação | float4 | Float4 |
| Duplo | float8 | Float8 |
| Data | date | Data/Dia |
| Timestamp | timestamp | Date Milli |
| String | VARCHAR | Varchar |
| Bytes | bytes | Varbinary |
| BigDecimal | Decimal | Decimal |
| ARRAY | N/D (ver nota) | Lista |
**nota**
Atualmente, o Cloudera Impala não oferece suporte para os tipos agregados `ARRAY`, `MAP`, `STRUCT` ou `UNIONTYPE`. As colunas de tipos agregados são tratadas como colunas `VARCHAR` pelo SQL.
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O Cloudera Impala oferece suporte a partições estáticas. O conector do Athena para o Cloudera Impala pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento estático é altamente recomendado. O conector Cloudera Impala é resiliente ao controle de utilização devido à simultaneidade.
O conector do Athena para o Cloudera Impala executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Cloudera Impala pode combinar essas expressões e passá-las diretamente ao Cloudera Impala para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Cloudera Impala são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector Cloudera Impala é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Cloudera Impala, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Cloudera Impala. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/pom.xml) do conector Cloudera Impala em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudera-impala) em GitHub.com.
# Conector do Amazon Athena para o CloudWatch
O conector do CloudWatch no Amazon Athena permite que o Amazon Athena se comunique com o CloudWatch para que você possa consultar os dados de log com SQL.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
O conector mapeia os LogGroups como esquemas e cada LogStream como uma tabela. O conector também mapeia uma exibição `all_log_streams` especial que contém todos os LogStreams no LogGroup. Essa exibição permite consultar todos os logs em um LogGroup de uma só vez, em vez de pesquisar cada LogStream individualmente.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do CloudWatch.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do CloudWatch usando um objeto de conexões do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector do CloudWatch como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type CLOUDWATCH
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do CloudWatch criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do CloudWatch criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
O conector também oferece suporte a [Controle de congestionamento AIMD](https://en.wikipedia.org/wiki/Additive_increase/multiplicative_decrease) para lidar com eventos de limitação do CloudWatch por meio da construção `ThrottlingInvoker` do [SDK do Amazon Athena Query Federation](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). É possível ajustar o comportamento do controle de utilização padrão definindo qualquer uma das seguintes variáveis de ambiente opcionais:
+ **throttle\$1initial\$1delay\$1ms**: o atraso inicial da chamada aplicado após o primeiro evento de congestionamento. O padrão é de 10 milissegundos.
+ **throttle\$1max\$1delay\$1ms**: o atraso máximo entre as chamadas. É possível derivar o TPS dividindo-o em 1000 ms. O padrão é de 1000 milissegundos.
+ **throttle\$1decrease\$1factor**: o fator pelo qual o Athena reduz a taxa de chamadas. O padrão é de 0,5
+ **throttle\$1increase\$1ms**: a taxa na qual o Athena diminui o atraso da chamada. O padrão é de 10 milissegundos.
## Bancos de dados e tabelas
O conector CloudWatch do Athena mapeia seus LogGroups como esquemas (ou seja, bancos de dados) e cada LogStream como uma tabela. O conector também mapeia uma exibição `all_log_streams` especial que contém todos os LogStreams no LogGroup. Essa exibição permite consultar todos os logs em um LogGroup de uma só vez, em vez de pesquisar cada LogStream individualmente.
Cada tabela mapeada pelo conector CloudWatch do Athena possui o esquema a seguir. Esse esquema corresponde aos campos fornecidos pelo CloudWatch Logs.
+ **log\$1stream**: um `VARCHAR` que contém o nome do LogStream de onde a linha pertence.
+ **time**: um `INT64` que contém a época em que a linha de log foi gerada.
+ **message**: um `VARCHAR` que contém a mensagem de log.
**Exemplos**
O exemplo a seguir mostra como realizar uma consulta `SELECT` em um LogStream especificado.
```
SELECT *
FROM "lambda:cloudwatch_connector_lambda_name"."log_group_path"."log_stream_name"
LIMIT 100
```
O exemplo a seguir mostra como usar a visualização `all_log_streams` para executar uma consulta em todos os LogStreams em um LogGroup especificado.
```
SELECT *
FROM "lambda:cloudwatch_connector_lambda_name"."log_group_path"."all_log_streams"
LIMIT 100
```
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-cloudwatch.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudwatch/athena-cloudwatch.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **CloudWatch Logs Read/Write** (Leitura/gravação do CloudWatch Logs): o conector usa esta permissão para ler seus dados de log e gravar seus logs de diagnóstico.
## desempenho
O conector CloudWatch do Athena tenta otimizar as consultas em relação ao CloudWatch paralelizando as varreduras dos fluxos de log necessários para sua consulta. Para determinados filtros de período de tempo, a redução de predicados é realizada tanto na função do Lambda quanto no CloudWatch Logs.
Para obter a melhor performance, use somente letras minúsculas em nomes de grupos de logs e nomes de fluxos de logs. O uso de maiúsculas e minúsculas mistas faz com que o conector execute uma pesquisa que não diferencia maiúsculas de minúsculas e é mais computacionalmente intensiva.
**nota**
O conector do CloudWatch não é compatível com nomes de banco de dados em maiúsculas.
## Consultas de passagem
O conector do CloudWatch suporta [consultas de passagem](federated-query-passthrough.md) que usam a [sintaxe de consulta do CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html). Para obter mais informações sobre o CloudWatch Logs Insights, consulte [Analisar dados de log com o CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) no *Guia do usuário do Amazon CloudWatch Logs*.
Para criar consultas de passagem com o CloudWatch, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
STARTTIME => 'start_time',
ENDTIME => 'end_time',
QUERYSTRING => 'query_string',
LOGGROUPNAMES => 'log_group-names',
LIMIT => 'max_number_of_results'
))
```
O exemplo a seguir filtra a consulta de passagem do CloudWatch para o campo `duration` quando ele não é igual a 1000.
```
SELECT * FROM TABLE(
system.query(
STARTTIME => '1710918615308',
ENDTIME => '1710918615972',
QUERYSTRING => 'fields @duration | filter @duration != 1000',
LOGGROUPNAMES => '/aws/lambda/cloudwatch-test-1',
LIMIT => '2'
))
```
## Informações de licença
O projeto do conector CloudWatch do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) em GitHub.com.
# Conector do Amazon Athena para o CloudWatch Metrics
O conector das métricas do CloudWatch no Amazon Athena permite que o Amazon Athena consulte dados de métricas do CloudWatch com SQL.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
Para obter informações sobre a publicação de métricas de consulta do próprio Athena no CloudWatch, consulte [Usar o CloudWatch e o EventBridge para monitorar as consultas e controlar os custos](workgroups-control-limits.md).
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do CloudWatch Metrics.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do CloudWatch Metrics usando um objeto de conexões do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector do CloudWatch Metrics como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type CLOUDWATCHMETRICS
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do CloudWatch Metrics criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do CloudWatch Metrics criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
O conector também oferece suporte a [Controle de congestionamento AIMD](https://en.wikipedia.org/wiki/Additive_increase/multiplicative_decrease) para lidar com eventos de limitação do CloudWatch por meio da construção `ThrottlingInvoker` do [SDK do Amazon Athena Query Federation](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). É possível ajustar o comportamento do controle de utilização padrão definindo qualquer uma das seguintes variáveis de ambiente opcionais:
+ **throttle\$1initial\$1delay\$1ms**: o atraso inicial da chamada aplicado após o primeiro evento de congestionamento. O padrão é de 10 milissegundos.
+ **throttle\$1max\$1delay\$1ms**: o atraso máximo entre as chamadas. É possível derivar o TPS dividindo-o em 1000 ms. O padrão é de 1000 milissegundos.
+ **throttle\$1decrease\$1factor**: o fator pelo qual o Athena reduz a taxa de chamadas. O padrão é de 0,5
+ **throttle\$1increase\$1ms**: a taxa na qual o Athena diminui o atraso da chamada. O padrão é de 10 milissegundos.
## Bancos de dados e tabelas
O conector CloudWatch Metrics do Athena mapeia seus namespaces, dimensões, métricas e valores métricos em duas tabelas em um único esquema chamado `default`.
### A tabela de métricas
A tabela `metrics` contém as métricas disponíveis conforme definido exclusivamente por uma combinação de namespace, conjunto e nome. A tabela `metrics` contém as colunas a seguir.
+ **namespace**: um `VARCHAR` contendo o namespace.
+ **metric\$1name**: um `VARCHAR` contendo o nome da métrica.
+ **dimensions**: uma `LIST` de objetos `STRUCT` compostos por `dim_name (VARCHAR)` e `dim_value (VARCHAR)`.
+ **statistic**: uma `LIST` de estatísticas `VARCH` (por exemplo, `p90`, `AVERAGE`, ...) disponíveis para a métrica.
### A tabela metric\$1samples
A tabela `metric_samples` contém as amostras métricas disponíveis para cada métrica na tabela `metrics`. A tabela `metric_samples` contém as colunas a seguir.
+ **namespace**: um `VARCHAR` que contém o namespace.
+ **metric\$1name**: um `VARCHAR` que contém o nome da métrica.
+ **dimensions**: uma `LIST` de objetos `STRUCT` compostos por `dim_name (VARCHAR)` e `dim_value (VARCHAR)`.
+ **dim\$1name**: um campo `VARCHAR` de conveniência que você pode usar para filtrar facilmente por um único nome de dimensão.
+ **dim\$1value**: um campo `VARCHAR` de conveniência que você pode usar para filtrar facilmente por um único valor de dimensão.
+ **period**: um campo `INT` que representa o “período” da métrica em segundos (por exemplo, uma métrica de 60 segundos).
+ **timestamp**: um campo `BIGINT` que representa o tempo de época em segundos para o qual a amostra métrica se destina.
+ **value**: um `FLOAT8` campo que contém o valor da amostra.
+ **statistic**: um `VARCHAR` que contém o tipo estatístico da amostra (por exemplo, `AVERAGE` ou `p90`).
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-cloudwatch-metrics.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudwatch-metrics/athena-cloudwatch-metrics.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **CloudWatch Metrics ReadOnly** (Métricas do CloudWatch somente para leitura): o conector usa esta permissão para consultar seus dados de métricas.
+ **CloudWatch Logs Write**: o conector usa este acesso para gravar seus registros de diagnóstico.
## desempenho
O conector CloudWatch Metrics do Athena tenta otimizar as consultas em relação ao CloudWatch Metrics paralelizando as varreduras dos fluxos de log necessários para sua consulta. Para determinados filtros de período de tempo, métricas, namespaces e dimensões, a redução de predicados é realizada tanto na função do Lambda quanto no CloudWatch Logs.
## Informações de licença
O projeto do conector CloudWatch Metrics do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch-metrics) em GitHub.com.
# Conector do AWS CMDB no Amazon Athena
O conector do Amazon Athena para o AWS CMDB permite que o Athena se comunique com vários serviços da AWS para que você possa consultá-los com SQL.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do AWS CMDB.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do AWS CMDB usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do AWS CMDB com o nome da conexão do Glue que deseja usar.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type CMDB
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do AWS CMDB criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do AWS CMDB criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar o desempenho, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **default\$1ec2\$1image\$1owner**: (opcional) quando definido, controla o proprietário padrão da imagem do Amazon EC2 que filtra [Imagens de máquina da Amazon (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html). Se você não definir esse valor e sua consulta na tabela de imagens do EC2 não incluir um filtro para o proprietário, seus resultados incluirão todas as imagens públicas.
## Bancos de dados e tabelas
O conector AWS CMDB do Athena disponibiliza os seguintes bancos de dados e tabelas para consultar seu inventário de recursos da AWS. Para obter mais informações sobre as colunas disponíveis em cada tabela, execute uma declaração `DESCRIBE database.table` usando o console ou a API do Athena.
+ **ec2**: esse banco de dados contém recursos relacionados ao Amazon EC2, incluindo os seguintes.
+ **ebs\$1volumes**: contém detalhes dos seus volumes do Amazon EBS.
+ **ec2\$1instances**: contém detalhes das suas instâncias do EC2.
+ **ec2\$1images**: contém detalhes das suas imagens do EC2.
+ **routing\$1tables**: contém detalhes das suas tabelas de roteamento de VPC.
+ **security\$1groups**: contém detalhes dos seus grupos de segurança.
+ **subnets**: contém detalhes das suas sub-redes VPC.
+ **vpcs**: contém detalhes das suas VPCs.
+ **emr**: este banco de dados contém recursos relacionados ao Amazon EMR, incluindo os seguintes.
+ **emr\$1clusters**: contém detalhes dos seus clusters do EMR.
+ **rds**: este banco de dados contém recursos relacionados ao Amazon RDS, incluindo os seguintes.
+ **rds\$1instances**: contém detalhes das suas instâncias do RDS.
+ **s3**: este banco de dados contém recursos relacionados ao RDS, incluindo os seguintes.
+ **buckets**: contém detalhes dos buckets do Amazon S3.
+ **objects**: contém detalhes dos seus objetos do Amazon S3, excluindo seu conteúdo.
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-aws-cmdb.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-aws-cmdb/athena-aws-cmdb.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **S3 List** (Listar S3): o conector usa esta permissão para listar seus buckets e objetos do Amazon S3.
+ **EC2 Describe** (Descrever EC2): o conector usa esta permissão para descrever recursos, como suas instâncias do Amazon EC2, grupos de segurança, VPCs e volumes do Amazon EBS.
+ **EMR Describe / List** (Descrever / listar EMR): o conector usa esta permissão para descrever seus clusters do EMR.
+ **RDS Describe** (Descrever RDS): o conector usa esta permissão para descrever suas instâncias do RDS.
## Performance
Atualmente, o conector AWS CMDB do Athena não oferece suporte a verificações paralelas. A redução de predicados é realizada dentro da função do Lambda. Sempre que possível, predicados parciais são enviados para os serviços que estão sendo consultados. Por exemplo, uma consulta para obter os detalhes de uma instância específica do Amazon EC2 chama a API do EC2 com o ID de instância específico para executar uma operação de descrição direcionada.
## Informações de licença
O projeto do conector AWS CMDB do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-aws-cmdb) em GitHub.com.
# Conector IBM Db2 do Amazon Athena
O conector do Amazon Athena para Db2 possibilita que o Amazon Athena execute consultas SQL em seus bancos de dados do IBM Db2 usando o JDBC.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados date e timestamp para os tipos de dados apropriados.
## Termos
Os termos a seguir estão relacionados ao conector Db2.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Db2.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Db2 usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Db2 como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type DB2
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Db2 criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Db2 criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
dbtwo://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | Db2MuxCompositeHandler |
| Manipulador de metadados | Db2MuxMetadataHandler |
| Manipulador de registros | Db2MuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mydbtwocatalog, então o nome da variável de ambiente será mydbtwocatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades exemplificadas a seguir são para uma função MUX do Lambda para o Db2 compatível com duas instâncias de banco de dados: `dbtwo1` (o padrão) e `dbtwo2`.
****
| Propriedade | Valor |
| --- | --- |
| default | dbtwo://jdbc:db2://dbtwo1.hostname:port/database\$1name:\$1\$1secret1\$1name\$1 |
| dbtwo\$1catalog1\$1connection\$1string | dbtwo://jdbc:db2://dbtwo1.hostname:port/database\$1name:\$1\$1secret1\$1name\$1 |
| dbtwo\$1catalog2\$1connection\$1string | dbtwo://jdbc:db2://dbtwo2.hostname:port/database\$1name:\$1\$1secret2\$1name\$1 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${secret_name}`.
```
dbtwo://jdbc:db2://hostname:port/database_name:${secret_name}
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
dbtwo://jdbc:db2://hostname:port/database_name:user=user_name;password=password;
```
#### Uso de um único manipulador de conexão
É possível usar os metadados de conexão única e os manipuladores de registros a seguir para se conectar a uma única instância do Db2.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | Db2CompositeHandler |
| Manipulador de metadados | Db2MetadataHandler |
| Manipulador de registros | Db2RecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
A propriedade exemplificada a seguir é para uma única instância do Db2 compatível em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | dbtwo://jdbc:db2://hostname:port/database\$1name:\$1\$1secret\$1name\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Arrow.
****
| Db2 | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| DATE | DATEDAY |
| TIME | VARCHAR |
| TIMESTAMP | DATEMILLI |
| DATETIME | DATEMILLI |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | DECIMAL |
| REAL | FLOAT8 |
| DOUBLE | FLOAT8 |
| DECFLOAT | FLOAT8 |
## Partições e divisões
Uma partição é representada por uma ou mais colunas de partição do tipo `varchar`. O conector Db2 cria partições usando os esquemas de organização a seguir.
+ Distribuir por hash
+ Particionar por intervalo
+ Organizar por dimensões
O conector recupera detalhes da partição, como o número de partições e o nome da coluna de uma ou mais tabelas de metadados do Db2. As divisões são criadas com base no número de partições identificadas.
## desempenho
O conector do Athena para o Db2 executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Db2 pode combinar essas expressões e passá-las diretamente ao Db2 para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Db2 são compatíveis com a passagem de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector Db2 é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Db2, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Db2. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/pom.xml) para o conector Db2 em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-db2) em GitHub.com.
# Conector IBM Db2 AS/400 (Db2 iSeries) para Amazon Athena
O conector do Amazon Athena para Db2 AS/400 habilita o Amazon Athena a executar consultas SQL em seus bancos de dados IBM Db2 AS/400 (Db2 iSeries) usando o JDBC.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados date e timestamp para os tipos de dados apropriados.
## Termos
Os termos a seguir estão relacionados ao conector Db2 AS/400.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Db2 AS/400.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Db2 AS/400 usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Db2 AS/400 como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type DB2AS400
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Db2 AS/400 criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Db2 AS/400 criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
db2as400://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | Db2MuxCompositeHandler |
| Manipulador de metadados | Db2MuxMetadataHandler |
| Manipulador de registros | Db2MuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mydb2as400catalog, então o nome da variável de ambiente será mydb2as400catalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades exemplificadas a seguir são para uma função MUX do Lambda para o Db2 compatível com duas instâncias de banco de dados: `db2as4001` (o padrão) e `db2as4002`.
****
| Propriedade | Valor |
| --- | --- |
| default | db2as400://jdbc:as400://;;:\$1\$1\$1; |
| db2as400\$1catalog1\$1connection\$1string | db2as400://jdbc:as400://db2as4001.hostname/:\$1\$1secret1\$1name\$1 |
| db2as400\$1catalog2\$1connection\$1string | db2as400://jdbc:as400://db2as4002.hostname/:\$1\$1secret2\$1name\$1 |
| db2as400\$1catalog3\$1connection\$1string | db2as400://jdbc:as400://;user=;password=;; |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${secret_name}`.
```
db2as400://jdbc:as400://;;:${};
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
db2as400://jdbc:as400://;user=;password=;;
```
#### Uso de um único manipulador de conexão
É possível usar os metadados de conexão única e os manipuladores de registros a seguir para se conectar a uma única instância do Db2 AS/400.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | Db2CompositeHandler |
| Manipulador de metadados | Db2MetadataHandler |
| Manipulador de registros | Db2RecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
A propriedade exemplificada a seguir é para uma única instância do Db2 AS/400 compatível em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | db2as400://jdbc:as400://;;:\$1\$1\$1; |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Apache Arrow.
****
| Db2 AS/400 | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| DATE | DATEDAY |
| TIME | VARCHAR |
| TIMESTAMP | DATEMILLI |
| DATETIME | DATEMILLI |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | DECIMAL |
| REAL | FLOAT8 |
| DOUBLE | FLOAT8 |
| DECFLOAT | FLOAT8 |
## Partições e divisões
Uma partição é representada por uma ou mais colunas de partição do tipo `varchar`. O conector Db2 AS/400 cria partições usando os esquemas de organização a seguir.
+ Distribuir por hash
+ Particionar por intervalo
+ Organizar por dimensões
O conector recupera detalhes da partição, como o número de partições e o nome da coluna, de uma ou mais tabelas de metadados do Db2 AS/400. As divisões são criadas com base no número de partições identificadas.
## desempenho
Para melhorar o desempenho, use o pushdown de predicados para consultar o Athena, como nos exemplos a seguir.
```
SELECT * FROM "lambda:"."".""
WHERE integercol = 2147483647
```
```
SELECT * FROM "lambda: "."".""
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Consultas de passagem
O conector Db2 AS/400 é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Db2 AS/400, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Db2 AS/400. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/pom.xml) para o conector Db2 AS/400 em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-db2-as400) em GitHub.com.
# Conector do DocumentDB no Amazon Athena
O conector Amazon Athena para o DocumentDB permite que o Athena se comunique com suas instâncias do DocumentDB para que você possa consultar seus dados do DocumentDB com SQL. O conector também funciona com qualquer endpoint compatível com o MongoDB.
Diferentemente dos armazenamentos de dados relacionais tradicionais, as coleções do Amazon DocumentDB não têm um esquema definido. O DocumentDB não tem um armazenamento de metadados. Cada entrada em uma coleção do DocumentDB pode ter diferentes campos e tipos de dados.
O conector DocumentDB oferece suporte a dois mecanismos para gerar informações do esquema da tabela: inferência básica de esquema e metadados do AWS Glue Data Catalog.
A inferência de esquema é o padrão. Essa opção examina um pequeno número de documentos em sua coleção, forma uma união de todos os campos e força campos que têm tipos de dados não sobrepostos. Essa opção funciona bem para coleções que têm, em sua maioria, entradas uniformes.
Para coleções com uma maior variedade de tipos de dados, o conector oferece suporte à recuperação de metadados do AWS Glue Data Catalog. Se o conector vê um banco de dados do AWS Glue e uma tabela que correspondam aos nomes de seu banco de dados e coleção do DocumentDB, ele obtém suas informações de esquema da tabela AWS Glue correspondente. Quando você cria sua tabela AWS Glue, recomendamos que você a torne um superconjunto de todos os campos que você talvez queira acessar da sua coleção do DocumentDB.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do DocumentDB.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do DocumentDB usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do DocumentDB como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type DOCUMENTDB
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do DocumentDB criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do DocumentDB criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue**: (opcional) se estiver presente e definido como verdadeiro, o conector não tentará recuperar metadados complementares do AWS Glue.
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
+ **default\$1docdb**: se estiver presente, especifica uma string de conexão do DocumentDB a ser usada quando não existir uma variável de ambiente específica do catálogo.
+ **disable\$1projection\$1and\$1casing**: (opcional) desativa a projeção e a capitalização. Use se quiser consultar tabelas do Amazon DocumentDB que usam nomes de colunas que diferenciam letras maiúsculas de minúsculas. O parâmetro `disable_projection_and_casing` usa os seguintes valores para especificar o comportamento do mapeamento de capitalização e coluna:
+ **false** (falso): essa é a configuração padrão. A projeção está ativada e o conector espera que todos os nomes das colunas estejam usando letras minúsculas.
+ **true** (verdadeiro): desativa a projeção e o uso de maiúsculas e minúsculas. Ao usar o parâmetro `disable_projection_and_casing`, lembre-se dos seguintes pontos:
+ O uso do parâmetro pode resultar em um maior uso de largura de banda. Além disso, se a função do Lambda não estiver na mesma Região da AWS que a fonte de dados, custos mais altos de transferência padrão entre regiões da AWS serão gerados como resultado do maior uso de largura de banda. Para obter mais informações sobre os custos de transferência entre regiões, consulte [Cobranças de transferência de dados da AWS para arquiteturas com servidor e com tecnologia sem servidor](https://aws.amazon.com/blogs/apn/aws-data-transfer-charges-for-server-and-serverless-architectures/) no blog da rede de parceiros da AWS.
+ Como um número maior de bytes é transferido, e o maior número de bytes exige um maior tempo de desserialização, a latência geral pode aumentar.
+ **enable\$1case\$1insensitive\$1match**: (opcional) quando `true`, realiza pesquisas sem distinção entre maiúsculas e minúsculas em nomes de esquemas e de tabelas no Amazon DocumentDB. O padrão é `false`. Use se sua consulta contiver nomes de esquemas ou de tabelas com letras maiúsculas.
#### Especificação de strings de conexão
É possível fornecer uma ou mais propriedades que definem os detalhes da conexão do DocumentDB para as instâncias do DocumentDB que você usar com o conector. Para fazer isso, defina uma variável de ambiente Lambda que corresponda ao nome do catálogo que você deseja usar no Athena. Por exemplo, suponha que você queira usar as seguintes consultas para consultar duas instâncias diferentes do DocumentDB no Athena:
```
SELECT * FROM "docdb_instance_1".database.table
```
```
SELECT * FROM "docdb_instance_2".database.table
```
Antes de usar essas duas instruções de SQL, você deverá adicionar duas variáveis de ambiente à sua função do Lambda: `docdb_instance_1` e `docdb_instance_2`. O valor para cada uma deverá ser uma string de conexão do DocumentDB no seguinte formato:
```
mongodb://:@:/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0
```
##### Uso de segredos
Opcionalmente, é possível usar o AWS Secrets Manager para obter parte ou todo o valor dos detalhes da string de conexão. Para usar o recurso Athena Federated Query com o Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
Se você usar a sintaxe `${my_secret}` para colocar o nome de um segredo do Secrets Manager na string de conexão, o conector substituirá `${my_secret}` por seu valor em texto sem formatação do Secrets Manager exatamente. Os segredos devem ser armazenados como um segredo de texto sem formatação com o valor de `:`. Os segredos armazenados como `{username:,password:}` não serão passados corretamente para a string de conexão.
Os segredos também podem ser usados para toda a string de conexão, e o nome de usuário e a senha podem ser definidos no segredo.
Por exemplo, suponha que você defina a variável de ambiente Lambda para `docdb_instance_1` com o seguinte valor:
```
mongodb://${docdb_instance_1_creds}@myhostname.com:123/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0
```
O SDK do Athena Query Federation tenta automaticamente recuperar um segredo chamado `docdb_instance_1_creds` do Secrets Manager e injetar esse valor no lugar de `${docdb_instance_1_creds}`. Qualquer parte da string de conexão que esteja delimitada pela combinação de caracteres `${ }` será é interpretada como um segredo do Secrets Manager. Se você especificar um nome secreto que o conector não consiga encontrar no Secrets Manager, o conector não substituirá o texto.
## Recuperar metadados complementares
Para recuperar os metadados complementares, siga estas etapas para configurar o banco de dados e a tabela do Glue.
### Configurar o banco de dados do Glue
1. Crie um banco de dados do Glue com o mesmo nome da coleção do DocumentDB.
1. No campo URI de localização, insira `docdb-metadata-flag`.
### Configurar a tabela do Glue
Adicione os seguintes parâmetros à tabela do Glue:
+ `docdb-metadata-flag = true`
+ `columnMapping = apple=APPLE`
Neste exemplo, `apple` representa o nome da coluna em minúsculas no Glue e `APPLE` representa o nome real da coluna que diferencia maiúsculas de minúsculas na coleção do DocumentDB.
### Verificar recuperação de metadados
1. Execute a consulta.
1. Verifique nos logs do CloudWatch da função do Lambda se a recuperação de metadados foi bem-sucedida. Uma recuperação bem-sucedida mostrará a seguinte entrada de log:
```
doGetTable: Retrieved schema for table[TableName{schemaName=test, tableName=profiles}] from AWS Glue.
```
**nota**
Se a tabela já tiver um campo `columnMapping` configurado, será necessário apenas adicionar o parâmetro `docdb-metadata-flag = true` às propriedades da tabela.
## Configuração de bancos de dados e tabelas no AWS Glue
Como o recurso de inferência de esquema integrado do conector examina um número limitado de documentos e oferece suporte apenas um subconjunto de tipos de dados, talvez você queira usar o AWS Glue para metadados, em vez disso.
Para habilitar uma tabela do AWS Glue para uso com o Amazon DocumentDB, você deve ter um banco de dados do AWS Glue e uma tabela para o banco de dados DocumentDB e a coleção para a qual você deseja fornecer metadados complementares.
**Para usar uma tabela do AWS Glue para metadados complementares**
1. Use o console do AWS Glue para criar um banco de dados do AWS Glue com o mesmo nome do banco de dados Amazon DocumentDB.
1. Defina a propriedade de URI do banco de dados para incluir **docdb-metadata-flag**.
1. (Opcional) Adicione a propriedade de tabela **sourceTable**. Essa propriedade define o nome da tabela de origem no Amazon DocumentDB. Use essa propriedade se o nome da tabela do AWS Glue for diferente do nome da tabela no Amazon DocumentDB. Diferenças nas regras de nomenclatura entre o AWS Glue e Amazon DocumentDB podem fazer com que isso seja necessário. Por exemplo, não é permitido usar letras maiúsculas em nomes de tabelas do AWS Glue, mas é permitido usá-las em nomes de tabelas do Amazon DocumentDB.
1. (Opcional) Adicione a propriedade de tabela **columnMapping**. Essa propriedade define mapeamentos de nomes de colunas. Use essa propriedade caso as regras de nomenclatura de colunas do AWS Glue impeçam que você crie uma tabela do AWS Glue com os mesmos nomes de coluna da tabela do Amazon DocumentDB. Ela pode ser útil porque letras maiúsculas são permitidas nos nomes de colunas do Amazon DocumentDB, mas não são permitidas nos nomes de colunas do AWS Glue.
Espera-se que o valor da propriedade `columnMapping` seja um conjunto de mapeamentos no formato `col1=Col1,col2=Col2`.
**nota**
O mapeamento de colunas só é aplicável a nomes de colunas de nível superior e não a campos aninhados.
Após adicionar a propriedade de tabela `columnMapping` do AWS Glue, é possível remover a variável de ambiente `disable_projection_and_casing` do Lambda.
1. Use os tipos de dados apropriados para o AWS Glue, conforme listado neste documento.
## Suporte ao tipo de dados
Esta seção lista os tipos de dados que o conector DocumentDB usa para inferência de esquema e os tipos de dados quando metadados do AWS Glue forem usados.
### Tipos de dados de inferência de esquema
O recurso de inferência de esquema do conector DocumentDB tenta inferir valores como pertencentes a um dos seguintes tipos de dados. A tabela mostra os tipos de dados correspondentes para o Amazon DocumentDB, Java e Apache Arrow.
****
| Apache Arrow | Java ou DocDB |
| --- | --- |
| VARCHAR | String |
| INT | Inteiro |
| BIGINT | Longo |
| BIT | Booleano |
| FLOAT4 | Float |
| FLOAT8 | Duplo |
| TIMESTAMPSEC | Data |
| VARCHAR | ObjectId |
| LIST | Lista |
| STRUCT | Documento |
### AWS GlueTipos de dados do
Se você usar o AWS Glue para metadados complementares, será possível poderá configurar os tipos de dados a seguir. A tabela mostra os correspondentes tipos de dados do AWS Glue e do Apache Arrow.
****
| AWS Glue | Apache Arrow |
| --- | --- |
| int | INT |
| bigint | BIGINT |
| double | FLOAT8 |
| flutuação | FLOAT4 |
| booleano | BIT |
| binary | VARBINARY |
| string | VARCHAR |
| Lista | LIST |
| Struct | STRUCT |
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-docdb.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-docdb/athena-docdb.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector DocumentDB requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
+ **Acesso de leitura do AWS Secrets Manager**: se você optar por armazenar os detalhes do endpoint do DocumentDB no Secrets Manager, deverá conceder ao conector acesso a esses segredos.
+ **Acesso à VPC**: o conector exige a capacidade de conectar e desconectar interfaces à sua VPC para que ela possa se conectar a ela e se comunicar com suas instâncias do DocumentDB.
## desempenho
No momento, o conector Amazon DocumentDB do Athena não é compatível com verificações paralelas, mas tenta empilhar predicados como parte de suas consultas ao DocumentDB, e predicados em relação a índices na coleção do DocumentDB resultam em, significantemente, menos dados verificados.
A função do Lambda executa o empilhamento de projeções para diminuir os dados verificados pela consulta. No entanto, selecionar um subconjunto de colunas, às vezes, resulta em um runtime de consulta mais longo. As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados.
## Consultas de passagem
O conector do Amazon DocumentDB para Athena é compatível com [consultas de passagem](federated-query-passthrough.md) e é baseado em NoSQL. Para obter mais informações sobre como fazer consultas ao Amazon DocumentDB, consulte [Como fazer consultas](https://docs.aws.amazon.com/documentdb/latest/developerguide/querying.html) no *Guia do desenvolvedor do Amazon DocumentDB*.
Para usar consultas de passagem com o Amazon DocumentDB, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
database => 'database_name',
collection => 'collection_name',
filter => '{query_syntax}'
))
```
O exemplo a seguir consulta o banco de dados `example` da coleção `TPCDS`, filtrando todos os livros com o título *Bill of Rights*.
```
SELECT * FROM TABLE(
system.query(
database => 'example',
collection => 'tpcds',
filter => '{title: "Bill of Rights"}'
))
```
## Recursos adicionais
+ Para um artigo sobre o uso da [Consulta federada do Amazon Athena](federated-queries.md) para conectar um banco de dados MongoDB ao [Quick](https://aws.amazon.com/quicksight/) para criar painéis e visualizações, consulte [Visualize dados do MongoDB do Quick usando a consulta federada do Amazon Athena](https://aws.amazon.com/blogs/big-data/visualize-mongodb-data-from-amazon-quicksight-using-amazon-athena-federated-query/) no *AWS Big Data Blog*.
+ Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-docdb) em GitHub.com.
# Conector do Amazon Athena para o DynamoDB
O conector do DynamoDB no Amazon Athena permite que o Amazon Athena se comunique com o DynamoDB para que você possa consultar suas tabelas com SQL. Operações de gravação como [INSERT INTO](insert-into.md) não são suportadas.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
Se você migrar suas conexões do DynamoDB para o Glue Catalog e o Lake Formation, somente os nomes das tabelas e colunas em minúsculas serão reconhecidos.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do DynamoDB.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do DynamoDB usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do DynamoDB com o nome da conexão do Glue que deseja usar.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type DYNAMODB
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do DynamoDB criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do DynamoDB criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue**: (opcional) se estiver presente e definido como verdadeiro, o conector não tentará recuperar metadados complementares do AWS Glue.
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
+ **disable\$1projection\$1and\$1casing**: (opcional) desativa a projeção e a capitalização. Use se quiser consultar tabelas do DynamoDB que tenham maiúsculas e minúsculas em seus nomes de coluna e não quiser especificar uma propriedade `columnMapping` em sua tabela AWS Glue.
O parâmetro `disable_projection_and_casing` usa os seguintes valores para especificar o comportamento do mapeamento de capitalização e coluna:
+ **auto**: desativa a projeção e a capitalização quando um tipo anteriormente sem suporte é detectado e o mapeamento do nome da coluna não está definido na tabela. Essa é a configuração padrão.
+ **always** (sempre): desativa a projeção e a capitalização incondicionalmente. Isso é útil quando você tem maiúsculas e minúsculas nos nomes das colunas do DynamoDB, mas não quer especificar nenhum mapeamento de nome de coluna.
Ao usar o parâmetro `disable_projection_and_casing`, lembre-se dos seguintes pontos:
+ O uso do parâmetro pode resultar em um maior uso de largura de banda. Além disso, se a função do Lambda não estiver na mesma Região da AWS que a fonte de dados, custos mais altos de transferência padrão entre regiões da AWS serão gerados como resultado do maior uso de largura de banda. Para obter mais informações sobre os custos de transferência entre regiões, consulte [Cobranças de transferência de dados da AWS para arquiteturas com servidor e com tecnologia sem servidor](https://aws.amazon.com/blogs/apn/aws-data-transfer-charges-for-server-and-serverless-architectures/) no blog da rede de parceiros da AWS.
+ Como um número maior de bytes é transferido, e o maior número de bytes exige um maior tempo de desserialização, a latência geral pode aumentar.
## Configuração de bancos de dados e tabelas no AWS Glue
Como a capacidade incorporada de inferência de esquema do conector é limitada, talvez você queira usar o AWS Glue para metadados. Para fazer isso, você deve ter um banco de dados e uma tabela no AWS Glue. Para habilitá-los para uso com o DynamoDB, você deve editar suas propriedades.
**Para editar as propriedades do banco de dados no console do AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, expanda **Data Catalog** e escolha **Bancos de dados**.
Na página **Databases** (Bancos de dados), você pode editar um banco de dados existente ou escolher **Add database** (Adicionar banco de dados) para criar um.
1. Na lista de bancos de dados, selecione o link do banco de dados que deseja editar.
1. Escolha **Editar**.
1. Na página **Atualizar um banco de dados**, em **Configurações de banco de dados**, para **Local**, adicione a string **dynamo-db-flag**. Essa palavra-chave indica que o banco de dados contém tabelas que o conector DynamoDB para Athena está usando para metadados complementares e é necessária para bancos de dados do AWS Glue diferentes de `default`. A propriedade `dynamo-db-flag` é útil para filtrar bancos de dados em contas com muitos bancos de dados.
1. Escolha **Update Database** (Atualizar banco de dados).
**Para editar as propriedades da tabela no console do AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, expanda **Data Catalog** e escolha **Tebelas**.
1. Na página **Tabelas**, na lista de tabelas, escolha o nome do link para a tabela que você deseja editar.
1. Selecione **Actions** (Ações), **Edit** (Editar).
1. Na página **Edit table** (Editar tabela), na seção **Table properties** (Propriedades de tabela), adicione as seguintes propriedades de tabela, conforme solicitado: Se você usar o crawler do DynamoDB do AWS Glue, essas propriedades serão definidas automaticamente.
+ **DynamoDB**: string que indica ao conector DynamoDB do Athena que a tabela pode ser usada para metadados complementares. Insira a string `dynamodb` nas propriedades da tabela em um campo chamado **classification** (classificação) (correspondência exata).
**nota**
A página **Definir propriedades da tabela**, que é parte do processo de criação de tabelas no console no AWS Glue, tem uma seção **Formato dos dados** com um campo **Classificação**. Você não pode inserir nem escolher o `dynamodb` aqui. Em vez disso, depois de criar a tabela, siga as etapas para editar a tabela e inserir `classification` e `dynamodb` como um par de chave/valor na seção **Propriedades da tabela**.
+ **sourceTable**: propriedade de tabela opcional que define o nome da tabela de origem no DynamoDB. Use-a caso as regras de nomenclatura de tabelas do AWS Glue impeçam que você crie uma tabela do AWS Glue com o mesmo nome da sua tabela do DynamoDB. Por exemplo, letras maiúsculas não são permitidas em nomes de tabelas do AWS Glue, mas são permitidas nos nomes de tabelas do DynamoDB.
+ **columnMapping**: propriedade de tabela opcional que define mapeamentos de nomes de colunas. Use-a caso as regras de nomenclatura de colunas do AWS Glue impeçam que você crie uma tabela do AWS Glue com os mesmos nomes de coluna da sua tabela do DynamoDB. Por exemplo, letras maiúsculas não são permitidas em nomes de colunas do AWS Glue, mas são permitidas nos nomes de colunas do DynamoDB. Espera-se que o valor da propriedade esteja no formato col1=Col1,col2=Col2. Observe que o mapeamento de colunas só é aplicável a nomes de colunas de nível superior e não a campos aninhados.
+ **defaultTimeZone**: propriedade de tabela opcional que é aplicada a valores `date` ou `datetime` que não tenham um fuso horário explícito. Definir esse valor é uma boa prática para evitar discrepâncias entre o fuso horário padrão da fonte de dados e o fuso horário da sessão do Athena.
+ **datetimeFormatMapping**: propriedade de tabela opcional que especifica o formato de `date` ou `datetime` a ser usado ao analisar dados de uma coluna do AWS Glue de tipo de dado `date` ou `timestamp`. Se essa propriedade não for especificada, o conector tentará [inferir](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/time/DateFormatUtils.html) um formato ISO-8601. Se o conector não puder inferir o formato `date` ou `datetime`, ou analisar a string bruta, então o valor será omitido do resultado.
O valor de `datetimeFormatMapping` deve estar no formato `col1=someformat1,col2=someformat2`. Veja a seguir alguns exemplos de formatos:
```
yyyyMMdd'T'HHmmss
ddMMyyyy'T'HH:mm:ss
```
Se sua coluna tiver valores `date` ou `datetime` sem um fuso horário, e você desejar usar a coluna na cláusula `WHERE`, defina a propriedade `datetimeFormatMapping` para a coluna.
1. Se você definir suas colunas manualmente, certifique-se de usar os tipos de dados apropriados. Se você usou um crawler, valide as colunas e os tipos que o crawler descobriu.
1. Escolha **Salvar**.
## Permissões obrigatórias
Revise a seção `Policies` do arquivo [athena-dynamodb.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-dynamodb/athena-dynamodb.yaml) para obter detalhes completos sobre as políticas do IAM que esse conector exige. A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector DynamoDB requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
+ **Acesso de leitura do DynamoDB**: o conector usa as operações da API `DescribeTable`, `ListSchemas`, `ListTables`, `Query` e `Scan`.
## desempenho
O conector Athena DynamoDB oferece suporte a verificações paralelas e tentativas de reduzir predicados como parte de suas consultas do DynamoDB. Um predicado de chave de hash com `X` valores distintos resulta em `X` chamadas de consulta para o DynamoDB. Todos os outros cenários de predicados resultam em um número `Y` de chamadas de exame, onde `Y` é determinado heuristicamente com base no tamanho da tabela e na throughput provisionada. Porém, selecionar um subconjunto de colunas resulta, algumas vezes, em um runtime mais longo.
Cláusulas `LIMIT` e predicados simples são passados diretamente e podem reduzir a quantidade de dados examinados e reduzir o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. Para melhorar a funcionalidade e reduzir a quantidade de dados examinados, o conector do Athena para o DynamoDB pode combinar essas expressões e passá-las diretamente ao DynamoDB.
Os seguintes operadores do conector do Athena para o DynamoDB são compatíveis com a passagem direta de predicados:
+ **Booleano: **E
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10 and col_b < 10
LIMIT 10
```
Para ver um artigo sobre como usar o pushdown de predicado para melhorar o desempenho em consultas federadas, incluindo DynamoDB, consulte [Melhorar as consultas federadas com o pushdown de predicados no Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) no *AWSBlog de Big Data*.
## Consultas de passagem
O conector do DynamoDB é compatível com [consultas de passagem](federated-query-passthrough.md) e usa a sintaxe partiQL. Não há compatibilidade com a operação de API [GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html) do DynamoDB. Para obter informações sobre como consultar o DynamoDB usando o PartiQL, consulte [Instruções selecionadas do partiQL para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) no *Guias do desenvolvedor do Amazon DynamoDB*.
Para usar consultas de passagem com o DynamoDB, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query_string'
))
```
O seguinte exemplo de consulta de passagem do DynamoDB usa partiQL para retornar uma lista de dispositivos Fire TV Stick com uma propriedade `DateWatched` posterior a 24/12/22.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT Devices
FROM WatchList
WHERE Devices.FireStick.DateWatched[0] > '12/24/22''
))
```
## Solução de problemas
### Vários filtros em uma coluna de chave de classificação
**Mensagem de erro**: KeyConditionExpressions deve conter apenas uma condição por chave
**Causa**: este problema pode ocorrer no mecanismo Athena versão 3 em consultas que tenham um filtro limitado inferior e superior em uma coluna de chave de classificação do DynamoDB. Como o DynamoDB não oferece suporte a mais de uma condição de filtro em uma chave de classificação, ocorre um erro quando o conector tenta propagar uma consulta que tenha as duas condições aplicadas.
**Solução**: atualize o conector para a versão 2023.11.1 ou posterior. Para obter instruções sobre como atualizar um conector, consulte [Atualizar um conector de fonte de dados](connectors-updating.md).
## Custos
Os custos de uso do conector dependem dos recursos subjacentes da AWS que são usados. Como as consultas que usam verificações podem consumir um grande número de [unidades de capacidade de leitura (RCUs)](https://aws.amazon.com/dynamodb/pricing/provisioned/), considere as informações para [Definição de preços do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) com cuidado.
## Recursos adicionais
+ Para uma introdução ao uso do conector Amazon Athena DynamoDB, consulte [Acesse, consulte e una tabelas Amazon DynamoDB usando o Athena](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/access-query-and-join-amazon-dynamodb-tables-using-athena.html) no guia *AWSPadrões de Orientação Prescritiva*.
+ Para ver um artigo sobre como usar o conector do Athena DynamoDB para consultar dados no DynamoDB com SQL e visualizar insights no Quick, consulte a postagem [Visualize Amazon DynamoDB insights in Amazon Quick using the Amazon Athena DynamoDB connector and AWS Glue](https://aws.amazon.com/blogs/big-data/visualize-amazon-dynamodb-insights-in-amazon-quicksight-using-the-amazon-athena-dynamodb-connector-and-aws-glue/) em *AWS Big Data Blog*.
+ Para ler um artigo sobre o uso do conector do Amazon Athena DynamoDB com o Amazon DynamoDB, o Athena e o Quick para criar um painel de governança simples, consulte a postagem [Consulte tabelas Amazon DynamoDB entre contas usando a consulta federada Amazon Athena](https://aws.amazon.com/blogs/big-data/query-cross-account-amazon-dynamodb-tables-using-amazon-athena-federated-query/) no *AWS Big Data Blog*.
+ Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-dynamodb) em GitHub.com.
# Conector do Amazon Athena para o Google BigQuery
O conector do Amazon Athena para o Google [BigQuery](https://cloud.google.com/bigquery/) permite que o Amazon Athena execute consultas SQL em seus dados do Google BigQuery.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ As funções do Lambda têm um valor máximo de tempo limite de 15 minutos. Cada divisão executa uma consulta no BigQuery e precisa terminar com tempo suficiente para armazenar os resultados para que o Athena leia. Se a função do Lambda atingir o tempo limite, a consulta falhará.
+ O Google BigQuery diferencia maiúsculas e minúsculas. O conector tenta corrigir a capitalização dos nomes dos conjuntos de dados, dos nomes das tabelas e dos ID de projetos. Isso é necessário porque o Athena coloca em minúsculas todos os metadados. Essas correções geram muitas chamadas extras para o Google BigQuery.
+ Não há suporte para o tipo de dado binário.
+ Devido à simultaneidade e aos limites de cota do Google BigQuery, o conector pode encontrar problemas de limite de cota do Google. Para evitar esses problemas, imponha o máximo possível de restrições ao Google BigQuery. Para obter informações sobre cotas do BigQuery, consulte [Cotas e limites](https://cloud.google.com/bigquery/quotas) na documentação do Google BigQuery.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Google BigQuery.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Google BigQuery usando um objeto de conexões do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do Google BigQuery com o nome da conexão do Glue que deseja usar.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type BIGQUERY
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Google BigQuery criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Google BigQuery criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar o desempenho, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **gcp\$1project\$1id**: o ID do projeto (não o nome do projeto) que contém os conjuntos de dados que o conector deve ler (por exemplo, `semiotic-primer-1234567`).
+ **secret\$1manager\$1gcp\$1creds\$1name**: o nome do segredo no AWS Secrets Manager que contém suas credenciais do BigQuery no formato JSON (por exemplo, `GoogleCloudPlatformCredentials`).
+ **big\$1query\$1endpoint**: (opcional) o URL de um endpoint privado do BigQuery. Use esse parâmetro quando quiser acessar o BigQuery por meio de um endpoint privado.
## Divisões e exibições
Como o conector BigQuery usa a API Storage Read do BigQuery para consultar tabelas, e a API Storage do BigQuery não é compatível com exibições, o conector usa o cliente do BigQuery com uma única divisão para exibições.
## desempenho
Para consultar tabelas, o conector BigQuery usa a API Storage Read do BigQuery, que usa um protocolo baseado em RPC que fornece acesso rápido ao armazenamento gerenciado do BigQuery. Para obter mais informações sobre a API BigQuery Storage Read, consulte [Use the BigQuery Storage Read API to read table data](https://cloud.google.com/bigquery/docs/reference/storage) na documentação do Google Cloud.
A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector está sujeito a falhas de consulta à medida que a simultaneidade aumenta e, de forma geral, é um conector lento.
O conector do Athena para o Google BigQuery executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, cláusulas `ORDER BY`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Principais N consultas
Uma das `N` principais consultas especifica uma ordenação do conjunto de resultados e um limite no número de linhas retornadas. Você pode usar esse tipo de consulta para determinar os `N` principais valores máximos ou `N` principais valores mínimos para os conjuntos de dados. Com os `N` pushdown principais, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Google BigQuery pode combinar essas expressões e passá-las diretamente ao Google BigQuery para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Google BigQuery são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
ORDER BY col_a DESC
LIMIT 10;
```
## Consultas de passagem
O conector Google BigQuery é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Google BigQuery, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Google BigQuery. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
O projeto do conector Google BigQuery do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-google-bigquery/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-google-bigquery/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-google-bigquery) em GitHub.com.
# Conector Google Cloud Storage para Amazon Athena
O conector Google Cloud Storage para Amazon Athena permite que o Amazon Athena execute consultas em arquivos Parquet e CSV armazenados em um bucket do Google Cloud Storage (GCS). Depois de agrupar um ou mais arquivos Parquet ou CSV em uma pasta não particionada ou particionada em um bucket do GCS, você poderá organizá-los em uma tabela de banco de dados do [AWS Glue](https://aws.amazon.com/glue/).
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
Para ver um artigo que mostra como usar o Athena para executar consultas em arquivos Parquet ou CSV em um bucket do GCS, consulte a postagem [Use Amazon Athena to query data stored in Google Cloud Platform](https://aws.amazon.com/blogs/big-data/use-amazon-athena-to-query-data-stored-in-google-cloud-platform/). no AWS Big Data Blog.
## Pré-requisitos
+ Configure um banco de dados e uma tabela do AWS Glue que correspondam ao seu bucket e suas pastas no Google Cloud Storage. Para ver as etapas, consulte [Configuração de bancos de dados e tabelas no AWS Glue](#connectors-gcs-setting-up-databases-and-tables-in-glue) mais adiante neste documento.
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Atualmente, o conector é compatível somente com o tipo `VARCHAR` de colunas de partição (`string` ou `varchar` em um esquema de tabela do AWS Glue). Outros tipos de campo de partição geram erros quando você os consulta no Athena.
## Termos
Os termos a seguir estão relacionados ao conector GCS.
+ **Manipulador**: um manipulador Lambda que acessa seu bucket do GCS. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados do seu bucket do GCS.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados do seu bucket do GCS.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados do seu bucket do GCS.
## Tipos de arquivos compatíveis
O conector GCS é compatível com os tipos de arquivo Parquet e CSV.
**nota**
Certifique-se de não colocar os arquivos CSV e Parquet no mesmo bucket ou caminho do GCS. Isso pode resultar em um erro de runtime se houver tentativa de ler os arquivos Parquet como CSV ou vice-versa.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do GCS.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do GCS usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do GCS como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type GOOGLECLOUDSTORAGE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do GCS criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do GCS criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **secret\$1manager\$1gcp\$1creds\$1name**: o nome do segredo no AWS Secrets Manager que contém suas credenciais do GCS no formato JSON (por exemplo, `GoogleCloudPlatformCredentials`).
## Configuração de bancos de dados e tabelas no AWS Glue
Como a capacidade de inferência de esquema integrada do conector GCS é limitada, recomendamos que você use o AWS Glue para seus metadados. Os procedimentos a seguir mostram como criar um banco de dados e uma tabela do AWS Glue que você possa acessar a partir do Athena.
### Criação de um banco de dados no AWS Glue
Você pode usar o console do AWS Glue para criar um banco de dados para uso com o conector GCS.
**Para criar um banco de dados no AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Escolha **Databases** (Bancos de dados) no painel de navegação.
1. Selecione **Adicionar banco de dados**.
1. Em **Name** (Nome), insira um nome para o banco de dados que você deseja usar com o conector GCS.
1. Em **Local**, especifique `google-cloud-storage-flag`. Esse local informa ao conector do GCS que o banco de dados do AWS Glue contém as tabelas para os dados do GCS para consulta no Athena. O conector reconhece bancos de dados no Athena que têm esse sinalizador e ignora bancos de dados que não o têm.
1. Selecione **Criar banco de dados**.
### Criar uma tabela no AWS Glue
Agora você pode criar uma tabela para o banco de dados. Ao criar uma tabela do AWS Glue para usar com o conector GCS, você deve especificar metadados adicionais.
**Para criar uma tabela no console do AWS Glue**
1. No painel de navegação do console do AWS Glue, escolha **Tables** (Tabelas).
1. Na página **Tables** (Tabelas), escolha **Add table** (Adicionar tabela).
1. Na página **Set table properties** (Definir propriedades da tabela), insira as informações a seguir.
+ **Name** (Tabela): um nome exclusivo para a tabela.
+ **Banco de dados**: escolha o banco de dados do AWS Glue que você criou para o conector GCS.
+ **Include path** (Incluir caminho): Na seção **Data store** (Armazenamento de dados), em **Include path** (Incluir caminho), insira a localização do URI para GCS prefixada por `gs://` (por exemplo, `gs://gcs_table/data/`). Se você tiver uma ou mais pastas de partição, não as inclua no caminho.
**nota**
Quando você insere um caminho de table que não é do `s3://` tabela, o console do AWS Glue mostra um erro. Você pode ignorar esse erro. A tabela será criada com êxito.
+ **Formato de dados**: para **Classification** (Classificação), selecione **CSV** ou **Parquet**.
1. Escolha **Próximo**.
1. Na página **Choose or define schema** (Escolher ou definir esquema), definir um esquema de tabela é altamente recomendado, mas não obrigatório. Se você não definir um esquema, o conector GCS tentará inferir um esquema para você.
Execute um destes procedimentos:
+ Se você quiser que o conector GCS tente inferir um esquema para você, escolha **Next** (Próximo) e, em seguida, escolha **Create** (Criar).
+ Para definir um esquema você mesmo, siga as etapas da próxima seção.
### Definir um esquema de tabela no AWS Glue
Definir um esquema de tabela no AWS Glue requer mais etapas, mas oferece maior controle sobre o processo de criação da tabela.
**Para definir um esquema para sua tabela no AWS Glue**
1. Na página **Choose or define schema** (Escolher ou definir esquema), escolha **Add** (Adicionar).
1. Use a caixa de diálogo **Add schema entry** (Adicionar entrada de esquema) para fornecer um nome de coluna e um tipo de dados.
1. Para designar a coluna como uma coluna de partição, selecione a opção **Set as partition key** (Definir como chave de partição).
1. Escolha **Save** (Salvar) para salvar a alteração.
1. Selecione **Add** (Adicionar) para adicionar outra coluna.
1. Ao terminar de adicionar contas, escolha **Next** (Próximo).
1. Na página **Review and create** (Revisar e criar), revise a configuração e selecione **Create** (Criar).
1. Se o esquema contiver informações sobre partições, siga as etapas na próxima seção para adicionar um padrão de partição às propriedades da tabela em AWS Glue.
### Adicionar um padrão de partição às propriedades da tabela no AWS Glue
Se seus buckets do GCS tiverem partições, você deverá adicionar o padrão de partição às propriedades da tabela no AWS Glue.
**Para adicionar informações de partição às propriedades da tabela do AWS Glue**
1. Na página de detalhes da tabela que você criou em AWS Glue, escolha **Actions** (Ações), **Edit table** (Editar tabela).
1. Na página **Edit table** (Editar tabela), role para baixo até a seção **Table properties** (Propriedades da tabela).
1. Escolha **Add** (Adicionar) para adicionar uma chave de partição.
1. Em **Chave**, digite **partition.pattern**. Essa chave define o padrão do caminho da pasta.
1. Em **Value** (Valor), insira um padrão de caminho de pasta como **StateName=\$1\$1statename\$1/ZipCode=\$1\$1zipcode\$1/**, em que **statename** e **zipcode** delimitados por **\$1\$1\$1** são nomes de colunas de partição. O conector GCS é compatível com esquemas de partição Hive e não Hive.
1. Quando terminar, escolha **Salvar**.
1. Para visualizar as propriedades da tabela que você acabou de criar, escolha a guia **Advanced properties** (Propriedades avançadas).
Nesse ponto, você pode navegar até o console do Athena. O banco de dados e a tabela que você criou no AWS Glue estão disponíveis para consulta no Athena.
## Suporte ao tipo de dados
As tabelas a seguir mostram os tipos de dados com suporte para CSV e Parquet.
### CSV
****
| **Natureza dos dados** | **Tipo de dados inferido** |
| --- | --- |
| Os dados parecem um número | BIGINT |
| Os dados parecem uma string | VARCHAR |
| Os dados parecem de ponto flutuante (flutuante, duplo ou decimal) | DOUBLE |
| Os dados parecem uma data | Timestamp |
| Dados que contêm valores verdadeiros/falsos | BOOL |
### Parquet
****
| **PARQUET** | **Athena (Seta)** |
| --- | --- |
| BINARY | VARCHAR |
| BOOLEAN | BOOL |
| DOUBLE | DOUBLE |
| ENUM | VARCHAR |
| FIXED\$1LEN\$1BYTE\$1ARRAY | DECIMAL |
| FLOAT | FLOAT (32 bits) |
| INT32 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-gcs.html) |
| INT64 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-gcs.html) |
| INT96 | Timestamp |
| MAP | MAP |
| STRUCT | STRUCT |
| LIST | LIST |
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-gcs.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/athena-gcs.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector GCS requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
## desempenho
Quando o esquema da tabela contém campos de partição e a propriedade `partition.pattern` da tabela está configurada corretamente, você pode incluir o campo de partição na cláusula `WHERE` de suas consultas. Para essas consultas, o conector GCS usa as colunas de partição para refinar o caminho da pasta GCS e evitar a varredura de arquivos desnecessários nas pastas do GCS.
Para conjuntos de dados Parquet, selecionar um subconjunto de colunas resulta em menos dados sendo verificados. Isso geralmente resulta em um runtime de consulta mais curto quando a projeção de coluna é aplicada.
Para conjuntos de dados CSV, a projeção de colunas não é compatível e não reduz a quantidade de dados que estão sendo digitalizados.
As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados. O conector GCS examina mais dados para conjuntos de dados maiores do que para conjuntos de dados menores, independentemente da cláusula `LIMIT` aplicada. Por exemplo, a consulta `SELECT * LIMIT 10000` examina mais dados em busca de um conjunto de dados subjacente maior do que de um menor.
### Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/LICENSE.txt) em GitHub.com.
### Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-gcs) em GitHub.com.
# Conector do Amazon Athena para o HBase
O conector do HBase no Amazon Athena permite que o Amazon Athena se comunique com as instâncias do Apache HBase para que você possa consultar os dados do HBase com SQL.
Diferentemente dos armazenamentos de dados relacionais tradicionais, as coleções do HBase não têm um esquema definido. O HBase não tem um armazenamento de metadados. Cada entrada em uma coleção do HBase pode ter diferentes campos e tipos de dados.
O conector HBase oferece suporte a dois mecanismos para gerar informações do esquema da tabela: inferência básica de esquema e metadados do AWS Glue Data Catalog.
A inferência de esquema é o padrão. Essa opção examina um pequeno número de documentos em sua coleção, forma uma união de todos os campos e força campos que têm tipos de dados não sobrepostos. Essa opção funciona bem para coleções que têm, em sua maioria, entradas uniformes.
Para coleções com uma maior variedade de tipos de dados, o conector oferece suporte à recuperação de metadados do AWS Glue Data Catalog. Se o conector vê um banco de dados do AWS Glue e uma tabela que correspondam aos nomes de seu namespace do HBase e nomes de coleção, ele obtém suas informações de esquema da tabela AWS Glue correspondente. Quando você cria sua tabela AWS Glue, recomendamos que você a torne um superconjunto de todos os campos que você talvez queira acessar da sua coleção do HBase.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do HBase.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do HBase usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do HBase como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type HBASE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do HBase criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do HBase criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue**: (opcional) se estiver presente e definido como verdadeiro, o conector não tentará recuperar metadados complementares do AWS Glue.
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
+ **default\$1hbase**: se estiver presente, especifica uma string de conexão do HBase a ser usada quando não existir uma variável de ambiente específica do catálogo.
+ **enable\$1case\$1insensitive\$1match**: (opcional) caso seja `true`, realiza pesquisas sem distinção entre maiúsculas e minúsculas em nomes de tabelas no HBase. O padrão é `false`. Use se sua consulta contiver nomes de tabelas com letras maiúsculas.
#### Especificação de strings de conexão
É possível fornecer uma ou mais propriedades que definem os detalhes da conexão do HBase para as instâncias do HBase que você usar com o conector. Para fazer isso, defina uma variável de ambiente Lambda que corresponda ao nome do catálogo que você deseja usar no Athena. Por exemplo, suponha que você queira usar as seguintes consultas para consultar duas instâncias diferentes do HBase no Athena:
```
SELECT * FROM "hbase_instance_1".database.table
```
```
SELECT * FROM "hbase_instance_2".database.table
```
Antes de usar essas duas instruções de SQL, você deverá adicionar duas variáveis de ambiente à sua função do Lambda: `hbase_instance_1` e `hbase_instance_2`. O valor para cada uma deverá ser uma string de conexão do HBase no seguinte formato:
```
master_hostname:hbase_port:zookeeper_port
```
##### Uso de segredos
Opcionalmente, é possível usar o AWS Secrets Manager para obter parte ou todo o valor dos detalhes da string de conexão. Para usar o recurso Athena Federated Query com o Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
Se você usar a sintaxe `${my_secret}` para colocar o nome de um segredo do Secrets Manager em sua string de conexão, o conector substituirá o nome do segredo pelos valores de seu nome de usuário e senha do Secrets Manager.
Por exemplo, suponha que você defina a variável de ambiente Lambda para `hbase_instance_1` com o seguinte valor:
```
${hbase_host_1}:${hbase_master_port_1}:${hbase_zookeeper_port_1}
```
O SDK do Athena Query Federation tenta automaticamente recuperar um segredo chamado `hbase_instance_1_creds` do Secrets Manager e injetar esse valor no lugar de `${hbase_instance_1_creds}`. Qualquer parte da string de conexão que esteja delimitada pela combinação de caracteres `${ }` será é interpretada como um segredo do Secrets Manager. Se você especificar um nome secreto que o conector não consiga encontrar no Secrets Manager, o conector não substituirá o texto.
## Configuração de bancos de dados e tabelas no AWS Glue
A inferência de esquema incorporada do conector oferece suporte somente a valores serializados no HBase, como strings (por exemplo, `String.valueOf(int)`). Como a capacidade incorporada de inferência de esquema do conector é limitada, talvez você queira usar o AWS Glue para metadados, em vez disso. Para habilitar uma tabela do AWS Glue para uso com o HBase, é preciso ter um banco de dados do AWS Glue e uma tabela com nomes que correspondam ao namespace do HBase e à tabela para a qual você deseja fornecer metadados complementares. O uso das convenções de nomenclatura da família de colunas do HBase é opcional, mas não obrigatório.
**Para usar uma tabela AWS Glue para metadados complementares**
1. Quando você editar a tabela e o banco de dados no console do AWS Glue, adicione as seguintes propriedades de tabela:
+ **hbase-metadata-flag**: essa propriedade indica ao conector HBase que o conector pode usar a tabela para metadados complementares. É possível fornecer qualquer valor para `hbase-metadata-flag`, desde que a propriedade `hbase-metadata-flag` esteja presente na lista de propriedades da tabela.
+ **hbase-native-storage-flag**: use esse sinalizador para alternar os dois modos de serialização de valores com suporte pelo conector. Por padrão, quando esse campo não estiver presente, o conector assumirá que todos os valores estão armazenados no HBase como strings. Como tal, ele tentará analisar tipos de dados como `INT`, `BIGINT` e `DOUBLE` do HBase como strings. Se esse campo for definido com qualquer valor na tabela em AWS Glue, o conector muda para o modo de armazenamento “nativo” e tenta ler `INT`, `BIGINT`, `BIT`, e `DOUBLE` como bytes usando as seguintes funções:
```
ByteBuffer.wrap(value).getInt()
ByteBuffer.wrap(value).getLong()
ByteBuffer.wrap(value).get()
ByteBuffer.wrap(value).getDouble()
```
1. Use os tipos de dados apropriados para o AWS Glue, conforme listado neste documento.
### Modelagem de famílias de colunas
O conector Athena HBase oferece suporte a duas formas de modelagem de famílias de colunas do HBase: nomenclatura totalmente qualificada (plana), como `family:column` ou usando objetos `STRUCT`.
No modelo `STRUCT`, o nome do campo `STRUCT` deve corresponder à família da coluna, e filhos do `STRUCT` devem corresponder aos nomes das colunas da família. No entanto, como ainda não há suporte total para a redução de predicados e as leituras colunares com tipos complexos como `STRUCT`, o uso de `STRUCT`, atualmente, não é recomendado.
A imagem a seguir mostra uma tabela configurada no AWS Glue que usa uma combinação das duas abordagens.
![\[Modelagem de famílias de colunas no AWS Glue para o Apache Hbase.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-hbase-1.png)
## Suporte ao tipo de dados
O conector recupera todos os valores do HBase como o tipo básico byte. Em seguida, com base em como você definiu suas tabelas no Catálogo de dados do AWS Glue, ele mapeia os valores em um dos tipos de dados do Apache Arrow na tabela a seguir.
****
| AWS GlueTipo de dados do | Tipo de dados Apache Arrow |
| --- | --- |
| int | INT |
| bigint | BIGINT |
| double | FLOAT8 |
| flutuação | FLOAT4 |
| booleano | BIT |
| binary | VARBINARY |
| string | VARCHAR |
**nota**
Se você não usar AWS Glue para complementar seus metadados, a inferência do esquema do conector usará somente os tipos de dados `BIGINT`, `FLOAT8` e `VARCHAR`.
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-hbase.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hbase/athena-hbase.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector HBase requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
+ **Acesso de leitura do AWS Secrets Manager**: se você optar por armazenar os detalhes do endpoint do HBase no Secrets Manager, deverá conceder ao conector acesso a esses segredos.
+ **Acesso à VPC**: o conector exige a capacidade de conectar e desconectar interfaces à sua VPC para que ela possa se conectar a ela e se comunicar com suas instâncias do HBase.
## desempenho
O conector Athena HBase tenta paralelizar as consultas em sua instância do HBase lendo cada servidor da região em paralelo. O conetor do Athena para o HBase realiza a passagem direta de predicados para diminuir os dados examinados pela consulta.
A função do Lambda também executa o empilhamento de *projeções* para diminuir os dados verificados pela consulta. No entanto, selecionar um subconjunto de colunas, às vezes, resulta em um runtime de consulta mais longo. As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados.
O HBase está propenso a falhas na consulta e tempos de execução variáveis para as consultas. Pode ser necessário repetir as consultas diversas vezes para que elas sejam bem-sucedidas. O conector HBase é resiliente ao controle de utilização devido à simultaneidade.
## Consultas de passagem
O conector do HBase é compatível com [consultas de passagem](federated-query-passthrough.md) e é baseado em NoSQL. Para obter informações sobre como consultar o Apache HBase usando filtros, consulte [Filter language](https://hbase.apache.org/book.html#thrift.filter_language) na documentação do Apache.
Para usar consultas de passagem com o HBase, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
database => 'database_name',
collection => 'collection_name',
filter => '{query_syntax}'
))
```
O exemplo a seguir de consulta de passagem do HBase filtra funcionários com 24 ou 30 anos na coleção `employee` do banco de dados `default`.
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'default',
COLLECTION => 'employee',
FILTER => 'SingleColumnValueFilter(''personaldata'', ''age'', =, ''binary:30'')' ||
' OR SingleColumnValueFilter(''personaldata'', ''age'', =, ''binary:24'')'
))
```
## Informações de licença
O projeto do conector HBase do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-hbase) em GitHub.com.
# Conector do Amazon Athena para a Hortonworks
O conector do Amazon Athena para a Hortonworks permite que o Amazon Athena execute consultas SQL na plataforma de dados [Hortonworks](https://www.cloudera.com/products/hdp.html) da Cloudera. O conector transforma suas consultas SQL do Athena na sintaxe equivalente do HiveQL.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
## Termos
Os termos a seguir estão relacionados ao conector Hortonworks Hive.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Hortonworks Hive.
### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
hive://${jdbc_connection_string}
```
### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | HiveMuxCompositeHandler |
| Manipulador de metadados | HiveMuxMetadataHandler |
| Manipulador de registros | HiveMuxRecordHandler |
#### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myhivecatalog, então o nome da variável de ambiente será myhivecatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Hive que ofereça suporte a duas instâncias de banco de dados: `hive1` (o padrão) e `hive2`.
****
| Propriedade | Valor |
| --- | --- |
| default | hive://jdbc:hive2://hive1:10000/default?\$1\$1Test/RDS/hive1\$1 |
| hive\$1catalog1\$1connection\$1string | hive://jdbc:hive2://hive1:10000/default?\$1\$1Test/RDS/hive1\$1 |
| hive\$1catalog2\$1connection\$1string | hive://jdbc:hive2://hive2:10000/default?UID=sample&PWD=sample |
#### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/hive1host}`.
```
hive://jdbc:hive2://hive1host:10000/default?...&${Test/RDS/hive1host}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
hive://jdbc:hive2://hive1host:10000/default?...&UID=sample2&PWD=sample2&...
```
Atualmente, o conector Hortonworks Hive reconhece as propriedades do JDBC `UID` e `PWD`.
### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Hortonworks Hive.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | HiveCompositeHandler |
| Manipulador de metadados | HiveMetadataHandler |
| Manipulador de registros | HiveRecordHandler |
#### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Hortonworks Hive com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | hive://jdbc:hive2://hive1host:10000/default?secret=\$1\$1Test/RDS/hive1host\$1 |
### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC, do Hortonworks Hive e do Arrow.
****
| JDBC | Hortonworks Hive | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Inteiro | TINYINT | Tiny |
| Short | SMALLINT | Smallint |
| Inteiro | INT | Int |
| Longo | BIGINT | Bigint |
| flutuação | float4 | Float4 |
| Duplo | float8 | Float8 |
| Data | date | Data/Dia |
| Timestamp | timestamp | Date Milli |
| String | VARCHAR | Varchar |
| Bytes | bytes | Varbinary |
| BigDecimal | Decimal | Decimal |
| ARRAY | N/D (ver nota) | Lista |
**nota**
Atualmente, o Hortonworks Hive não oferece suporte para os tipos agregados `ARRAY`, `MAP`, `STRUCT` ou `UNIONTYPE`. As colunas de tipos agregados são tratadas como colunas `VARCHAR` pelo SQL.
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O Hortonworks Hive oferece suporte a partições estáticas. O conector do Athena para o Hortonworks Hive pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento estático é altamente recomendado. A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector Hortonworks Hive é resiliente ao controle de utilização devido à simultaneidade.
O conector do Athena para o Hortonworks Hive executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados para o conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Hortonworks Hive pode combinar essas expressões e passá-las diretamente ao Hortonworks Hive para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Hortonworks Hive são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector Hortonworks Hive é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Hortonworks Hive, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Hortonworks Hive. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações sobre a versão do driver JDBC mais recentes, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/pom.xml) do conector Hortonworks Hive em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-hortonworks-hive) em GitHub.com.
# Conector do Apache Kafka do Amazon Athena
O conector do Amazon Athena para o Apache Kafka possibilita que o Amazon Athena execute consultas SQL em seus tópicos do Apache Kafka. Use esse conector para visualizar os tópicos e as mensagens do [Apache Kafka](https://kafka.apache.org/) no Athena como tabelas e linhas, respectivamente.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados date e timestamp para os tipos de dados apropriados.
+ Os tipos de dados data e timestamp não são compatíveis com o tipo de arquivo CSV e são tratados como valores varchar.
+ Não há suporte para o mapeamento em campos JSON aninhados. O conector mapeia somente os campos de nível superior.
+ O conector não é compatível com tipos complexos. Tipos complexos são interpretados como strings.
+ Para extrair ou trabalhar com valores JSON complexos, use as funções relacionadas ao JSON disponíveis no Athena. Para obter mais informações, consulte [Extrair dados JSON de strings](extracting-data-from-JSON.md).
+ O conector não oferece suporte ao acesso a metadados de mensagens do Kafka.
## Termos
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Endpoint do Kafka**: uma string de texto que estabelece uma conexão com uma instância do Kafka.
## Compatibilidade de cluster
O conector do Kafka pode ser usado com os seguintes tipos de cluster:
+ **Kafka dedicado**: uma conexão direta com o Kafka (autenticada ou não autenticada).
+ **Confluent** - Uma conexão direta com o Confluent Kafka. Para obter informações sobre como usar o Athena com dados do Confluent Kafka, consulte [Visualize dados do Confluent rapidamente usando o Amazon Athena](https://aws.amazon.com/blogs/business-intelligence/visualize-confluent-data-in-amazon-quicksight-using-amazon-athena/) em *AWS Business Intelligence Blog*.
### Conectando-se ao Confluent
A conexão com o Confluent requer as etapas a seguir:
1. Gere uma chave de API do Confluent.
1. Armazene o nome de usuário e a senha da chave da API Confluent em AWS Secrets Manager.
1. Forneça o nome secreto da variável de `secrets_manager_secret` ambiente no conector Kafka.
1. Siga as etapas na seção [Como configurar o conector do Kafka](#connectors-kafka-setup) deste documento.
## Métodos de autenticação compatíveis
O conector é compatível com os métodos de autenticação a seguir.
+ [SSL](https://kafka.apache.org/documentation/#security_ssl)
+ [SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram)
+ SASL/PLAIN
+ SASL/PLAINTEXT
+ NO\$1AUTH
+ **Plataforma Kafka e Confluent autogerenciada** - SSL, SASL/SCRAM, SASL/PLAINTEXT, NO\$1AUTH
+ **Kafka autogerenciado e Confluent Cloud** - SASL/PLAIN
Para obter mais informações, consulte [Configurar a autenticação do conector do Kafka para o Athena](#connectors-kafka-setup-configuring-authentication).
## Formatos de dados de entrada compatíveis
O conector é compatível com os seguintes formatos de dados de entrada:
+ JSON
+ CSV
+ AVRO
+ PROTOBUF (PROTOCOL BUFFERS)
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Kafka para o Athena.
+ **auth\$1type**: especifica o tipo de autenticação do cluster. O conector é compatível com os tipos de autenticação a seguir:
+ **NO\$1AUTH**: conexão direta ao Kafka (por exemplo, um cluster do Kafka implantado em uma instância do EC2 que não usa autenticação).
+ **SASL\$1SSL\$1PLAIN**: esse método usa o protocolo de segurança `SASL_SSL` e o mecanismo SASL `PLAIN`. Para obter mais informações, consulte [Configuração do SASL](https://kafka.apache.org/documentation/#security_sasl_config) na documentação do Apache Kafka.
+ **SASL\$1PLAINTEXT\$1PLAIN**: esse método usa o protocolo de segurança `SASL_PLAINTEXT` e o mecanismo SASL `PLAIN`. Para obter mais informações, consulte [Configuração do SASL](https://kafka.apache.org/documentation/#security_sasl_config) na documentação do Apache Kafka.
+ **SASL\$1SSL\$1SCRAM\$1SHA512**: você pode usar esse tipo de autenticação para controlar o acesso aos clusters do Apache Kafka. Esse método armazena o nome do usuário e a senha no AWS Secrets Manager. O segredo deve estar associado ao cluster do Kafka. Para obter mais informações, consulte [Autenticação usando SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram) na documentação do Apache Kafka.
+ **SASL\$1PLAINTEXT\$1SCRAM\$1SHA512**: este método usa o protocolo de segurança `SASL_PLAINTEXT` e o mecanismo `SCRAM_SHA512 SASL`. Esse método usa seu nome de usuário e a senha armazenados no AWS Secrets Manager. Para obter mais informações, consulte a seção [Configuração do SASL](https://kafka.apache.org/documentation/#security_sasl_config) na documentação do Apache Kafka.
+ **SSL**: a autenticação SSL usa os arquivos de armazenamento de chaves e de armazenamento confiável para se conectar ao cluster do Apache Kafka. Você deve gerar os arquivos de armazenamento confiável e de armazenamento de chaves, carregá-los em um bucket do Amazon S3 e fornecer a referência ao Amazon S3 ao implantar o conector. O armazenamento de chaves, o armazenamento confiável e a chave SSL serão armazenados no AWS Secrets Manager. Seu cliente deve fornecer a chave secreta da AWS ao implantar o conector. Para obter mais informações, consulte [Criptografia e autenticação usando SSL](https://kafka.apache.org/documentation/#security_ssl) na documentação do Apache Kafka.
Para obter mais informações, consulte [Configurar a autenticação do conector do Kafka para o Athena](#connectors-kafka-setup-configuring-authentication).
+ **certificates\$1s3\$1reference**: o local do Amazon S3 que contém os certificados (os arquivos de armazenamento de chaves e de armazenamento confiável).
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **kafka\$1endpoint**: os detalhes do endpoint a serem fornecidos para o Kafka.
+ **schema\$1registry\$1url** — O endereço URL do registro do esquema (por exemplo, `http://schema-registry.example.org:8081`). Aplica-se aos formatos de dados `AVRO` e `PROTOBUF`. O Athena só oferece suporte ao registro de esquema Confluent.
+ **secrets\$1manager\$1secret**: o nome do segredo da AWS no qual as credenciais são salvas.
+ **Parâmetros de vazamento**: as funções do Lambda armazenam temporariamente dados (“de vazamentos”) que não cabem na memória do Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local. Use os parâmetros na tabela a seguir para especificar o local do vazamento.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html)
+ **Subnet IDs** - Um ou mais IDs de sub-rede que correspondem à sub-rede que a função do Lambda pode usar para acessar sua fonte de dados.
+ **Cluster Kafka público ou cluster padrão do Confluent Cloud** — Associe o conector a uma sub-rede privada que tenha um gateway NAT.
+ **Cluster do Confluent Cloud com conectividade privada** - Associe o conector a uma sub-rede privada que tenha uma rota para o cluster Confluent Cloud.
+ Para o [AWS Transit Gateway](https://docs.confluent.io/cloud/current/networking/aws-transit-gateway.html), as sub-redes devem estar em uma VPC conectada ao mesmo gateway de trânsito que o Confluent Cloud usa.
+ No caso de [VPC Peering](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html), as sub-redes devem estar em uma VPC que está emparelhada com a VPC do Confluent Cloud.
+ Para [AWS PrivateLink](https://docs.confluent.io/cloud/current/networking/private-links/aws-privatelink.html), as sub-redes devem estar em uma VPC que tenha uma rota para os endpoints da VPC que se conectam ao Confluent Cloud.
**nota**
Se você implantar o conector em uma VPC para acessar recursos privados e também quiser estabelecer uma conexão com um serviço acessível ao público, como o Confluent, deverá associar o conector a uma sub-rede privada que tenha um gateway NAT. Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no Guia do usuário da Amazon VPC.
## Suporte ao tipo de dados
A tabela a seguir apresenta os tipos de dados correspondentes compatíveis com o Kafka e o Apache Arrow.
****
| Kafka | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| TIMESTAMP | MILLISECOND |
| DATE | DAY |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | FLOAT8 |
| DOUBLE | FLOAT8 |
## Partições e divisões
Os tópicos do Kafka são divididos em partições. Cada partição é ordenada. Cada mensagem em uma partição tem um ID incremental denominado *deslocamento*. Cada partição do Kafka é separada em diversas divisões para o processamento paralelo. Os dados estão disponíveis para o período de retenção configurado nos clusters do Kafka.
## Práticas recomendadas
Como prática recomendada, use o empilhamento de predicados ao consultar o Athena, como mostrado nos exemplos a seguir.
```
SELECT *
FROM "kafka_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE integercol = 2147483647
```
```
SELECT *
FROM "kafka_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Como configurar o conector do Kafka
Antes de usar o conector, você deve configurar seu cluster do Apache Kafka. Use o [registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html) para definir seu esquema e configurar a autenticação para o conector.
Ao trabalhar com o registro de esquemas do AWS Glue, preste atenção aos seguintes pontos:
+ Certifique-se de que o texto no campo **Description** (Descrição) do registro de esquemas do AWS Glue inclua a string `{AthenaFederationKafka}`. Essa string de marcação é necessária para os registros do AWS Glue usados com o conector do Kafka para o Amazon Athena.
+ Para obter a melhor performance, use somente letras minúsculas para nomes de banco de dados e nomes de tabela. O uso de maiúsculas e minúsculas mistas faz com que o conector execute uma pesquisa que não diferencia maiúsculas de minúsculas e é mais computacionalmente intensiva.
**Para configurar o ambiente do Apache Kafka e o registro de esquemas do AWS Glue**
1. Configure o ambiente do Apache Kafka.
1. Faça o upload do arquivo de descrição do tópico do Kafka (ou seja, seu esquema) no formato JSON para o registro de esquemas do AWS Glue. Para obter mais informações, consulte [Integração com o registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html) no Guia do desenvolvedor do AWS Glue.
1. Para usar o formato de dados `AVRO` ou `PROTOBUF` ao definir o esquema no Registro de esquemas do AWS Glue:
+ Em **Nome do esquema**, insira o nome do tópico do Kafka no mesmo formato de maiúsculas e minúsculas do original.
+ Para **Formato de dados**, escolha **Apache Avro** ou **Protocol Buffers**.
Para obter esquemas de exemplo, consulte a seção a seguir.
### Exemplos de esquema para o registro de esquemas do AWS Glue
Use o formato dos exemplos apresentados nessa seção ao fazer upload de seu esquema para o [registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html).
#### Exemplo de esquema: tipo JSON
No exemplo a seguir, o esquema a ser criado no registro de esquemas do AWS Glue especifica `json` como o valor para `dataFormat` e usa `datatypejson` para `topicName`.
**nota**
O valor para `topicName` deve usar a mesma capitalização que o nome do tópico no Kafka.
```
{
"topicName": "datatypejson",
"message": {
"dataFormat": "json",
"fields": [
{
"name": "intcol",
"mapping": "intcol",
"type": "INTEGER"
},
{
"name": "varcharcol",
"mapping": "varcharcol",
"type": "VARCHAR"
},
{
"name": "booleancol",
"mapping": "booleancol",
"type": "BOOLEAN"
},
{
"name": "bigintcol",
"mapping": "bigintcol",
"type": "BIGINT"
},
{
"name": "doublecol",
"mapping": "doublecol",
"type": "DOUBLE"
},
{
"name": "smallintcol",
"mapping": "smallintcol",
"type": "SMALLINT"
},
{
"name": "tinyintcol",
"mapping": "tinyintcol",
"type": "TINYINT"
},
{
"name": "datecol",
"mapping": "datecol",
"type": "DATE",
"formatHint": "yyyy-MM-dd"
},
{
"name": "timestampcol",
"mapping": "timestampcol",
"type": "TIMESTAMP",
"formatHint": "yyyy-MM-dd HH:mm:ss.SSS"
}
]
}
}
```
#### Exemplo de esquema: tipo CSV
No exemplo a seguir, o esquema a ser criado no registro de esquemas do AWS Glue especifica `csv` como o valor para `dataFormat` e usa `datatypecsvbulk` para `topicName`. O valor para `topicName` deve usar a mesma capitalização que o nome do tópico no Kafka.
```
{
"topicName": "datatypecsvbulk",
"message": {
"dataFormat": "csv",
"fields": [
{
"name": "intcol",
"type": "INTEGER",
"mapping": "0"
},
{
"name": "varcharcol",
"type": "VARCHAR",
"mapping": "1"
},
{
"name": "booleancol",
"type": "BOOLEAN",
"mapping": "2"
},
{
"name": "bigintcol",
"type": "BIGINT",
"mapping": "3"
},
{
"name": "doublecol",
"type": "DOUBLE",
"mapping": "4"
},
{
"name": "smallintcol",
"type": "SMALLINT",
"mapping": "5"
},
{
"name": "tinyintcol",
"type": "TINYINT",
"mapping": "6"
},
{
"name": "floatcol",
"type": "DOUBLE",
"mapping": "7"
}
]
}
}
```
#### Exemplo de esquema do tipo AVRO
O exemplo a seguir é usado para criar um esquema baseado em AVRO no Registro de esquemas do AWS Glue. Ao definir o esquema no Registro de esquemas do AWS Glue, em **Nome do esquema**, você insere o nome do tópico Kafka no mesmo formato de maiúsculas e minúsculas do original e, para **Formato de dados**, você escolhe **Apache Avro**. Como você especifica essas informações diretamente no registro, os campos `dataformat` e `topicName` não são obrigatórios.
```
{
"type": "record",
"name": "avrotest",
"namespace": "example.com",
"fields": [{
"name": "id",
"type": "int"
},
{
"name": "name",
"type": "string"
}
]
}
```
#### Exemplo de esquema do tipo PROTOBUF
O exemplo a seguir é usado para criar um esquema baseado em PROTOBUF no Registro de esquemas do AWS Glue. Ao definir o esquema no Registro de esquemas do AWS Glue, em **Nome do esquema**, você insere o nome do tópico Kafka no mesmo formato de maiúsculas e minúsculas do original e, para **Formato de dados**, você escolhe **Protocol Buffers**. Como você especifica essas informações diretamente no registro, os campos `dataformat` e `topicName` não são obrigatórios. A primeira linha define o esquema como PROTOBUF.
```
syntax = "proto3";
message protobuftest {
string name = 1;
int64 calories = 2;
string colour = 3;
}
```
Para obter mais informações sobre como adicionar um registro e esquemas no Registro de esquemas do AWS Glue, consulte [Conceitos básicos do registro de esquemas](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-gs.html) na documentação do AWS Glue.
### Configurar a autenticação do conector do Kafka para o Athena
É possível usar uma variedade de métodos para autenticar o cluster do Apache Kafka, como SSL, SASL/SCRAM, SASL/PLAIN e SASL/PLAINTEXT.
A tabela a seguir mostra os tipos de autenticação para o conector, e o protocolo de segurança e o mecanismo SASL para cada um. Para obter mais informações, consulte a seção [Segurança](https://kafka.apache.org/documentation/#security) da documentação do Apache Kafka.
****
| auth\$1type | security.protocol | sasl.mechanism | Compatibilidade do tipo de cluster |
| --- | --- | --- | --- |
| SASL\$1SSL\$1PLAIN | SASL\$1SSL | PLAIN | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html) |
| SASL\$1PLAINTEXT\$1PLAIN | SASL\$1PLAINTEXT | PLAIN | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html) |
| SASL\$1SSL\$1SCRAM\$1SHA512 | SASL\$1SSL | SCRAM-SHA-512 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html) |
| SASL\$1PLAINTEXT\$1SCRAM\$1SHA512 | SASL\$1PLAINTEXT | SCRAM-SHA-512 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html) |
| SSL | SSL | N/D | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-kafka.html) |
#### SSL
Se o cluster for autenticado por SSL, você deverá gerar os arquivos de armazenamento confiável e de armazenamento de chaves, e fazer o upload deles no bucket do Amazon S3. Você deverá fornecer essa referência do Amazon S3 ao implantar o conector. O armazenamento de chaves, o armazenamento confiável e a chave SSL serão armazenados no AWS Secrets Manager. Você fornecerá a chave secreta da AWS ao implantar o conector.
Para obter informações sobre como criar um segredo no Secrets Manager, consulte [Criação de um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
Para usar esse tipo de autenticação, defina as variáveis de ambiente conforme mostrado na tabela a seguir.
****
| Parâmetro | Valor |
| --- | --- |
| auth\$1type | SSL |
| certificates\$1s3\$1reference | O local do Amazon S3 que contém os certificados. |
| secrets\$1manager\$1secret | O nome da chave secreta da AWS. |
Após a criação de um segredo no Secrets Manager, é possível visualizá-lo no console do Secrets Manager.
**Para visualizar o segredo no Secrets Manager**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. No painel de navegação, escolha **Secrets** (Segredos).
1. Na página **Secrets** (Segredos), selecione o link do seu segredo.
1. Na página de detalhes do seu segredo, escolha **Retrieve secret value** (Recuperar valor do segredo).
A imagem a seguir apresenta um exemplo de segredo com três pares chave/valor: `keystore_password`, `truststore_password` e `ssl_key_password`.
![\[Recuperação de um segredo SSL no Secrets Manager\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-kafka-setup-1.png)
Para obter mais informações sobre como usar SSL com o Kafka, consulte [Criptografia e autenticação usando SSL](https://kafka.apache.org/documentation/#security_ssl) na documentação do Apache Kafka.
#### SASL/SCRAM
Se o cluster usar a autenticação SCRAM, forneça a chave do Secrets Manager associada ao cluster ao implantar o conector. As credenciais da AWS do usuário (chave secreta e chave de acesso) serão usadas para realizar a autenticação com o cluster.
Defina as variáveis de ambiente conforme mostrado na tabela a seguir.
****
| Parâmetro | Valor |
| --- | --- |
| auth\$1type | SASL\$1SSL\$1SCRAM\$1SHA512 |
| secrets\$1manager\$1secret | O nome da chave secreta da AWS. |
A imagem a seguir apresenta um exemplo de segredo no console do Secrets Manager com dois pares chave/valor: um para `username` e outro para `password`.
![\[Recuperação de um segredo SCRAM no Secrets Manager\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-kafka-setup-2.png)
Para obter mais informações sobre como usar o SASL/SCRAM com o Kafka, consulte [Autenticação usando SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram) na documentação do Apache Kafka.
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-kafka/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-kafka/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-kafka) em GitHub.com.
# Conector MSK do Amazon Athena
O conector do Amazon Athena para o [Amazon MSK](https://aws.amazon.com/msk/) possibilita que o Amazon Athena execute consultas SQL em seus tópicos do Apache Kafka. Use esse conector para visualizar os tópicos e as mensagens do [Apache Kafka](https://kafka.apache.org/) no Athena como tabelas e linhas, respectivamente. Para obter informações adicionais, consulte [Analyze real-time streaming data in Amazon MSK with Amazon Athena](https://aws.amazon.com/blogs/big-data/analyze-real-time-streaming-data-in-amazon-msk-with-amazon-athena/) (Analisar dados de streaming em tempo real no Amazon MSK com o Amazon Athena) no blog de big data da AWS.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados date e timestamp para os tipos de dados apropriados.
+ Os tipos de dados data e timestamp não são compatíveis com o tipo de arquivo CSV e são tratados como valores varchar.
+ Não há suporte para o mapeamento em campos JSON aninhados. O conector mapeia somente os campos de nível superior.
+ O conector não é compatível com tipos complexos. Tipos complexos são interpretados como strings.
+ Para extrair ou trabalhar com valores JSON complexos, use as funções relacionadas ao JSON disponíveis no Athena. Para obter mais informações, consulte [Extrair dados JSON de strings](extracting-data-from-JSON.md).
+ O conector não oferece suporte ao acesso a metadados de mensagens do Kafka.
## Termos
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Endpoint do Kafka**: uma string de texto que estabelece uma conexão com uma instância do Kafka.
## Compatibilidade de cluster
O conector MSK pode ser usado com os seguintes tipos de cluster:
+ **Cluster provisionado pelo MSK**: você especifica, monitora e escala manualmente a capacidade do cluster.
+ **Cluster do MSK Serverless**: fornece uma capacidade sob demanda que é escalada automaticamente conforme a escalabilidade de E/S da aplicação.
+ **Kafka dedicado**: uma conexão direta com o Kafka (autenticada ou não autenticada).
## Métodos de autenticação compatíveis
O conector é compatível com os métodos de autenticação a seguir.
+ [SASL/IAM](https://docs.aws.amazon.com/msk/latest/developerguide/iam-access-control.html)
+ [SSL](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html)
+ [SASL/SCRAM](https://docs.aws.amazon.com/msk/latest/developerguide/msk-password.html)
+ SASL/PLAIN
+ SASL/PLAINTEXT
+ NO\$1AUTH
Para obter mais informações, consulte [Configuração da autenticação para o conector MSK do Athena](#connectors-msk-setup-configuring-authentication).
## Formatos de dados de entrada compatíveis
O conector é compatível com os seguintes formatos de dados de entrada:
+ JSON
+ CSV
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do MSK para o Athena.
+ **auth\$1type**: especifica o tipo de autenticação do cluster. O conector é compatível com os tipos de autenticação a seguir:
+ **NO\$1AUTH**: conexão direta ao Kafka sem autenticação (por exemplo, um cluster do Kafka implantado em uma instância do EC2 que não usa autenticação).
+ **SASL\$1SSL\$1PLAIN**: esse método usa o protocolo de segurança `SASL_SSL` e o mecanismo SASL `PLAIN`.
+ **SASL\$1PLAINTEXT\$1PLAIN**: esse método usa o protocolo de segurança `SASL_PLAINTEXT` e o mecanismo SASL `PLAIN`.
**nota**
Os tipos de autenticação `SASL_SSL_PLAIN` e `SASL_PLAINTEXT_PLAIN` são compatíveis com o Apache Kafka, mas não no Amazon MSK.
+ **SASL\$1SSL\$1AWS\$1MSK\$1IAM**: o controle de acesso do IAM para o Amazon MSK permite que você gerencie a autenticação e a autorização para o cluster do MSK. As credenciais da AWS do seu usuário (chave secreta e chave de acesso) serão usadas para se conectar ao cluster. Para obter mais informações, consulte [IAM access control](https://docs.aws.amazon.com/msk/latest/developerguide/iam-access-control.html) (Controle de acesso do IAM) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
+ **SASL\$1SSL\$1SCRAM\$1SHA512**: você pode usar esse tipo de autenticação para controlar o acesso aos seus clusters do Amazon MSK. Esse método armazena o nome do usuário e a senha no AWS Secrets Manager. O segredo deve estar associado ao cluster do Amazon MSK. Para obter mais informações, consulte [Setting up SASL/SCRAM authentication for an Amazon MSK cluster](https://docs.aws.amazon.com/msk/latest/developerguide/msk-password.html#msk-password-tutorial) (Configuração da autenticação SASL/SCRAM para um cluster do Amazon MSK) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
+ **SSL**: a autenticação SSL usa os arquivos de armazenamento de chaves e de armazenamento confiável para se conectar ao cluster do Amazon MSK. Você deve gerar os arquivos de armazenamento confiável e de armazenamento de chaves, carregá-los em um bucket do Amazon S3 e fornecer a referência ao Amazon S3 ao implantar o conector. O armazenamento de chaves, o armazenamento confiável e a chave SSL serão armazenados no AWS Secrets Manager. Seu cliente deve fornecer a chave secreta da AWS ao implantar o conector. Para obter mais informações, consulte [Mutual TLS authentication](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html) (Autenticação mútua TLS) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
Para obter mais informações, consulte [Configuração da autenticação para o conector MSK do Athena](#connectors-msk-setup-configuring-authentication).
+ **certificates\$1s3\$1reference**: o local do Amazon S3 que contém os certificados (os arquivos de armazenamento de chaves e de armazenamento confiável).
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **kafka\$1endpoint**: os detalhes do endpoint a serem fornecidos para o Kafka. Por exemplo, para um cluster do Amazon MSK, você fornece um [URL de inicialização](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) para o cluster.
+ **secrets\$1manager\$1secret**: o nome do segredo da AWS no qual as credenciais são salvas. Esse parâmetro não é necessário para a autenticação do IAM.
+ **Parâmetros de vazamento**: as funções do Lambda armazenam temporariamente dados (“de vazamentos”) que não cabem na memória do Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local. Use os parâmetros na tabela a seguir para especificar o local do vazamento.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/connectors-msk.html)
## Suporte ao tipo de dados
A tabela a seguir apresenta os tipos de dados correspondentes compatíveis com o Kafka e o Apache Arrow.
****
| Kafka | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| TIMESTAMP | MILLISECOND |
| DATE | DAY |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | FLOAT8 |
| DOUBLE | FLOAT8 |
## Partições e divisões
Os tópicos do Kafka são divididos em partições. Cada partição é ordenada. Cada mensagem em uma partição tem um ID incremental denominado *deslocamento*. Cada partição do Kafka é separada em diversas divisões para o processamento paralelo. Os dados estão disponíveis para o período de retenção configurado nos clusters do Kafka.
## Práticas recomendadas
Como prática recomendada, use o empilhamento de predicados ao consultar o Athena, como mostrado nos exemplos a seguir.
```
SELECT *
FROM "msk_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE integercol = 2147483647
```
```
SELECT *
FROM "msk_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Configuração do conector MSK
Antes de usar o conector, você deve configurar seu cluster do Amazon MSK. Use o [registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html) para definir seu esquema e configurar a autenticação para o conector.
**nota**
Se você implantar o conector em uma VPC para acessar recursos privados e também quiser estabelecer uma conexão com um serviço acessível ao público, como o Confluent, deverá associar o conector a uma sub-rede privada que tenha um gateway NAT. Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no Guia do usuário da Amazon VPC.
Ao trabalhar com o registro de esquemas do AWS Glue, preste atenção aos seguintes pontos:
+ Certifique-se de que o texto no campo **Description** (Descrição) do registro de esquemas do AWS Glue inclua a string `{AthenaFederationMSK}`. Essa string de marcação é necessária para os registros do AWS Glue usados com o conector MSK do Amazon Athena.
+ Para obter a melhor performance, use somente letras minúsculas para nomes de banco de dados e nomes de tabela. O uso de maiúsculas e minúsculas mistas faz com que o conector execute uma pesquisa que não diferencia maiúsculas de minúsculas e é mais computacionalmente intensiva.
**Para configurar o ambiente do Amazon MSK e o registro de esquemas do AWS Glue**
1. Configure o ambiente do Amazon MSK. Para obter mais informações e etapas, consulte [Setting up Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/before-you-begin.html) (Configuração do Amazon MSK) e [Getting started using Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) (Comece a usar o Amazon MSK) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
1. Faça o upload do arquivo de descrição do tópico do Kafka (ou seja, seu esquema) no formato JSON para o registro de esquemas do AWS Glue. Para obter mais informações, consulte [Integração com o registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html) no Guia do desenvolvedor do AWS Glue. Para obter esquemas de exemplo, consulte a seção a seguir.
### Exemplos de esquema para o registro de esquemas do AWS Glue
Use o formato dos exemplos apresentados nessa seção ao fazer upload de seu esquema para o [registro de esquemas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html).
#### Exemplo de esquema: tipo JSON
No exemplo a seguir, o esquema a ser criado no registro de esquemas do AWS Glue especifica `json` como o valor para `dataFormat` e usa `datatypejson` para `topicName`.
**nota**
O valor para `topicName` deve usar a mesma capitalização que o nome do tópico no Kafka.
```
{
"topicName": "datatypejson",
"message": {
"dataFormat": "json",
"fields": [
{
"name": "intcol",
"mapping": "intcol",
"type": "INTEGER"
},
{
"name": "varcharcol",
"mapping": "varcharcol",
"type": "VARCHAR"
},
{
"name": "booleancol",
"mapping": "booleancol",
"type": "BOOLEAN"
},
{
"name": "bigintcol",
"mapping": "bigintcol",
"type": "BIGINT"
},
{
"name": "doublecol",
"mapping": "doublecol",
"type": "DOUBLE"
},
{
"name": "smallintcol",
"mapping": "smallintcol",
"type": "SMALLINT"
},
{
"name": "tinyintcol",
"mapping": "tinyintcol",
"type": "TINYINT"
},
{
"name": "datecol",
"mapping": "datecol",
"type": "DATE",
"formatHint": "yyyy-MM-dd"
},
{
"name": "timestampcol",
"mapping": "timestampcol",
"type": "TIMESTAMP",
"formatHint": "yyyy-MM-dd HH:mm:ss.SSS"
}
]
}
}
```
#### Exemplo de esquema: tipo CSV
No exemplo a seguir, o esquema a ser criado no registro de esquemas do AWS Glue especifica `csv` como o valor para `dataFormat` e usa `datatypecsvbulk` para `topicName`. O valor para `topicName` deve usar a mesma capitalização que o nome do tópico no Kafka.
```
{
"topicName": "datatypecsvbulk",
"message": {
"dataFormat": "csv",
"fields": [
{
"name": "intcol",
"type": "INTEGER",
"mapping": "0"
},
{
"name": "varcharcol",
"type": "VARCHAR",
"mapping": "1"
},
{
"name": "booleancol",
"type": "BOOLEAN",
"mapping": "2"
},
{
"name": "bigintcol",
"type": "BIGINT",
"mapping": "3"
},
{
"name": "doublecol",
"type": "DOUBLE",
"mapping": "4"
},
{
"name": "smallintcol",
"type": "SMALLINT",
"mapping": "5"
},
{
"name": "tinyintcol",
"type": "TINYINT",
"mapping": "6"
},
{
"name": "floatcol",
"type": "DOUBLE",
"mapping": "7"
}
]
}
}
```
### Configuração da autenticação para o conector MSK do Athena
É possível usar uma variedade de métodos para autenticar seu cluster do Amazon MSK, incluindo IAM, SSL, SCRAM e Kafka dedicado.
A tabela a seguir mostra os tipos de autenticação para o conector, e o protocolo de segurança e o mecanismo SASL para cada um. Para obter mais informações, consulte [Authentication and authorization for Apache Kafka APIs](https://docs.aws.amazon.com/msk/latest/developerguide/kafka_apis_iam.html) (Autenticação e autorização para APIs do Apache Kafka) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
****
| auth\$1type | security.protocol | sasl.mechanism |
| --- | --- | --- |
| SASL\$1SSL\$1PLAIN | SASL\$1SSL | PLAIN |
| SASL\$1PLAINTEXT\$1PLAIN | SASL\$1PLAINTEXT | PLAIN |
| SASL\$1SSL\$1AWS\$1MSK\$1IAM | SASL\$1SSL | AWS\$1MSK\$1IAM |
| SASL\$1SSL\$1SCRAM\$1SHA512 | SASL\$1SSL | SCRAM-SHA-512 |
| SSL | SSL | N/D |
**nota**
Há suporte para os tipos de autenticação `SASL_SSL_PLAIN` e `SASL_PLAINTEXT_PLAIN` no Apache Kafka, mas não no Amazon MSK.
#### SASL/IAM
Se o cluster usar a autenticação do IAM, você deverá configurar a política do IAM para o usuário ao configurar o cluster. Para obter mais informações, consulte [IAM access control](https://docs.aws.amazon.com/msk/latest/developerguide/IAM-access-control.html) (Controle de acesso do IAM) no Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka.
Para usar esse tipo de autenticação, defina a variável de ambiente do Lambda `auth_type` como `SASL_SSL_AWS_MSK_IAM` para o conector.
#### SSL
Se o cluster for autenticado por SSL, você deverá gerar os arquivos de armazenamento confiável e de armazenamento de chaves, e fazer o upload deles no bucket do Amazon S3. Você deverá fornecer essa referência do Amazon S3 ao implantar o conector. O armazenamento de chaves, o armazenamento confiável e a chave SSL serão armazenados no AWS Secrets Manager. Você fornecerá a chave secreta da AWS ao implantar o conector.
Para obter informações sobre como criar um segredo no Secrets Manager, consulte [Criação de um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
Para usar esse tipo de autenticação, defina as variáveis de ambiente conforme mostrado na tabela a seguir.
****
| Parâmetro | Valor |
| --- | --- |
| auth\$1type | SSL |
| certificates\$1s3\$1reference | O local do Amazon S3 que contém os certificados. |
| secrets\$1manager\$1secret | O nome da chave secreta da AWS. |
Após a criação de um segredo no Secrets Manager, é possível visualizá-lo no console do Secrets Manager.
**Para visualizar o segredo no Secrets Manager**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. No painel de navegação, escolha **Secrets** (Segredos).
1. Na página **Secrets** (Segredos), selecione o link do seu segredo.
1. Na página de detalhes do seu segredo, escolha **Retrieve secret value** (Recuperar valor do segredo).
A imagem a seguir apresenta um exemplo de segredo com três pares chave/valor: `keystore_password`, `truststore_password` e `ssl_key_password`.
![\[Recuperação de um segredo SSL no Secrets Manager\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-msk-setup-1.png)
#### SASL/SCRAM
Se o cluster usar a autenticação SCRAM, forneça a chave do Secrets Manager associada ao cluster ao implantar o conector. As credenciais da AWS do usuário (chave secreta e chave de acesso) serão usadas para realizar a autenticação com o cluster.
Defina as variáveis de ambiente conforme mostrado na tabela a seguir.
****
| Parâmetro | Valor |
| --- | --- |
| auth\$1type | SASL\$1SSL\$1SCRAM\$1SHA512 |
| secrets\$1manager\$1secret | O nome da chave secreta da AWS. |
A imagem a seguir apresenta um exemplo de segredo no console do Secrets Manager com dois pares chave/valor: um para `username` e outro para `password`.
![\[Recuperação de um segredo SCRAM no Secrets Manager\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-msk-setup-2.png)
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-msk/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-msk/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-msk) em GitHub.com.
# Conector do Amazon Athena para o MySQL
O conector MySQL do Lambda no Amazon Athena permite que o Amazon Athena acesse bancos de dados MySQL.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Como o Athena converte as consultas em minúsculas, os nomes das tabelas do MySQL devem estar em minúsculas. Por exemplo, consultas do Athena em uma tabela chamada `myTable` falharão.
+ Se você migrar suas conexões do MySQL para o Glue Catalog e o Lake Formation, somente os nomes das tabelas e colunas em minúsculas serão reconhecidos.
## Termos
Os termos a seguir estão relacionados ao conector MySQL.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do MySQL.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do MySQL usando um objeto de conexão do Glue.
Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do MySQL com o nome da conexão do Glue que deseja usar.
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type MYSQL
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do MySQL criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do MySQL criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
mysql://${jdbc_connection_string}
```
**nota**
Se você receber o erro java.sql.SQLException: Zero date value prohibited (Valor de data zero proibido) ao fazer uma consulta `SELECT` em uma tabela do MySQL, adicione o seguinte parâmetro à sua string de conexão:
```
zeroDateTimeBehavior=convertToNull
```
Para obter mais informações, consulte: [Erro 'Valor de data zero proibido' ao tentar selecionar em tabela do MySQL](https://github.com/awslabs/aws-athena-query-federation/issues/760) em GitHub.com.
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | MySqlMuxCompositeHandler |
| Manipulador de metadados | MySqlMuxMetadataHandler |
| Manipulador de registros | MySqlMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mymysqlcatalog, então o nome da variável de ambiente será mymysqlcatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do MySql que ofereça suporte a duas instâncias de banco de dados: `mysql1` (o padrão) e `mysql2`.
****
| Propriedade | Valor |
| --- | --- |
| default | mysql://jdbc:mysql://mysql2.host:3333/default?user=sample2&password=sample2 |
| mysql\$1catalog1\$1connection\$1string | mysql://jdbc:mysql://mysql1.host:3306/default?\$1\$1Test/RDS/MySql1\$1 |
| mysql\$1catalog2\$1connection\$1string | mysql://jdbc:mysql://mysql2.host:3333/default?user=sample2&password=sample2 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/MySql1}`.
```
mysql://jdbc:mysql://mysql1.host:3306/default?...&${Test/RDS/MySql1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
mysql://jdbc:mysql://mysql1host:3306/default?...&user=sample2&password=sample2&...
```
Atualmente, o conector MySQL reconhece as propriedades `user` e `password` do JDBC.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do MySQL.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | MySqlCompositeHandler |
| Manipulador de metadados | MySqlMetadataHandler |
| Manipulador de registros | MySqlRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do MySQL com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | mysql://mysql1.host:3306/default?secret=Test/RDS/MySQL1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Inteiro | Tiny |
| Short | Smallint |
| Inteiro | Int |
| Longo | Bigint |
| flutuação | Float4 |
| Duplo | Float8 |
| Data | Data/Dia |
| Timestamp | Date Milli |
| String | Varchar |
| Bytes | Varbinary |
| BigDecimal | Decimal |
| ARRAY | Lista |
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O MySQL oferece suporte a partições nativas. O conector do Athena para o Lambda pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento nativo é altamente recomendado.
O conector do Athena para o MySQL executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o MySQL pode combinar essas expressões e passá-las diretamente ao MySQL para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o MySQL são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
Para ver um artigo sobre como usar o pushdown de predicado para melhorar a performance em consultas federadas, incluindo MySQL, consulte [Melhorar as consultas federadas com o pushdown de predicados no Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) no *Blog de Big Data da AWS*.
## Consultas de passagem
O conector MySQL é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o MySQL, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no MySQL. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/pom.xml) do conector MySQL em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-mysql) em GitHub.com.
# Conector do Amazon Athena para o Neptune
O Amazon Neptune é um serviço de banco de dados de grafos rápido, confiável e totalmente gerenciado que facilita a criação e a execução de aplicações que trabalham com conjuntos de dados altamente conectados. O mecanismo de banco de dados de grafos especificamente projetado e de alta performance armazena bilhões de relacionamentos de maneira ideal e consulta gráficos com latência de poucos milissegundos. Para obter mais informações, consulte o [Manual do usuário do Neptune](https://docs.aws.amazon.com/neptune/latest/userguide/intro.html).
O conector do Neptune no Amazon Athena permite que o Athena se comunique com a instância de banco de dados de grafos do Neptune, tornando seus dados de grafos do Neptune acessíveis para consultas SQL.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
## Pré-requisitos
O uso do conector Neptune requer as três etapas a seguir.
+ Configuração de um cluster do Neptune
+ Configuração de um AWS Glue Data Catalog
+ Implantação do conector em sua Conta da AWS. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md). Para obter detalhes adicionais específicos sobre a implantação do conector Neptune, consulte [Implantação do conector Neptune no Amazon Athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/neptune-connector-setup) em GitHub.com.
## Limitações
No momento, o conector Neptune tem a seguinte limitação.
+ A projeção de colunas, incluindo a chave primária (ID), não é compatível.
## Configuração de um cluster do Neptune
Se você não tiver um cluster do Amazon Neptune e um conjunto de dados de gráfico de propriedades existentes que gostaria de usar, você deverá configurar um.
Verifique se você tem um gateway da Internet e um gateway NAT na VPC que hospeda seu cluster Neptune. As sub-redes privadas que a função do Lambda do conector Neptune usa devem ter uma rota para a Internet por meio desse gateway NAT. A função do Lambda do conector Neptune usa o gateway NAT para se comunicar com o AWS Glue.
Para obter instruções sobre como configurar um novo cluster do Neptune e carregá-lo com um conjunto de dados de amostra, consulte [Exemplo de configuração do cluster Neptune](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/neptune-cluster-setup) em GitHub.com.
## Configuração de um AWS Glue Data Catalog
Diferentemente dos armazenamentos de dados relacionais tradicionais, os nós e bordas do banco de dados gráfico do Neptune não usam um esquema definido. Cada entrada pode ter diferentes campos e tipos de dados. No entanto, como o conector Neptune recupera metadados do AWS Glue Data Catalog, você deve criar um banco de dados do AWS Glue que tenha tabelas com o esquema necessário. Depois de criar o banco de dados e as tabelas do AWS Glue, o conector poderá preencher a lista de tabelas disponíveis para consulta no Athena.
### Habilitar a correspondência de colunas sem distinção entre maiúsculas e minúsculas
Para resolver os nomes das colunas da tabela do Neptune com a capitalização correta, mesmo quando os nomes das colunas estão em minúsculas no AWS Glue, é possível configurar o conector do Neptune para correspondência sem distinção entre maiúsculas e minúsculas.
Para habilitar esse atributo, defina a variável de ambiente da função do Lambda do conector Neptune `enable_caseinsensitivematch` como `true`.
### Especificar o parâmetro de tabela glabel do AWS Glue para nomes de tabelas com distinção entre maiúsculas e minúsculas
Como o AWS Glue é compatível apenas com nomes de tabelas em letras minúsculas, é importante especificar o parâmetro `glabel` da tabela do AWS Glue ao criar uma tabela do AWS Glue para o Neptune e que a tabela do Neptune inclua distinção entre maiúsculas e minúsculas.
Na definição da tabela do AWS Glue, inclua o parâmetro `glabel` e defina seu valor para o nome da tabela com a capitalização original. Isso garante que a capitalização correta seja preservada quando o AWS Glue interagir com a tabela do Neptune. O exemplo a seguir define o valor de `glabel` para o nome de tabela `Airport`.
```
glabel = Airport
```
![\[Definir a propriedade de tabela glabel do AWS Glue para preservar a capitalização do nome da tabela em uma tabela do Neptune\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-neptune-1.png)
Para obter mais informações sobre como configurar um AWS Glue Data Catalog para trabalhar com o Neptune, consulte [Set up AWS Glue Catalog](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/aws-glue-sample-scripts) em GitHub.com.
## desempenho
O conector do Athena para o Neptune realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. No entanto, os predicados que usam a chave primária resultam em falhas na consulta. As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados. O conector Neptune é resiliente ao controle de utilização devido à simultaneidade.
## Consultas de passagem
O conector Neptune é compatível com [consultas de passagem](federated-query-passthrough.md). Você pode usar esse atributo para executar consultas Gremlin em gráficos de propriedades e executar consultas SPARQL em dados RDF.
Para usar consultas de passagem com o Neptune, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'database_name',
COLLECTION => 'collection_name',
QUERY => 'query_string'
))
```
O exemplo a seguir filtra a consulta de passagem do Neptune para aeroportos com o código `ATL`. As aspas simples duplas são para escapar.
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'graph-database',
COLLECTION => 'airport',
QUERY => 'g.V().has(''airport'', ''code'', ''ATL'').valueMap()'
))
```
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune) em GitHub.com.
# Conector do Amazon Athena para o OpenSearch
OpenSearch Service
O conector do OpenSearch no Amazon Athena permite que o Amazon Athena se comunique com suas instâncias do OpenSearch para que você possa usar o SQL para consultar os dados do OpenSearch.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
**nota**
Devido a um problema conhecido, o conector do OpenSearch não pode ser usado com uma VPC.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Termos
Os termos a seguir estão relacionados ao conector OpenSearch.
+ **Domínio**: um nome que esse conector associa ao endpoint da sua instância do OpenSearch. O domínio também é usado como nome do banco de dados. Para instâncias do OpenSearch definidas no Amazon OpenSearch Service, o domínio é detectável automaticamente. Para outras instâncias, você deve fornecer um mapeamento entre o nome de domínio e o endpoint.
+ **Índice**: uma tabela de banco de dados definida em sua instância do OpenSearch.
+ **Mapeamento**: se um índice for uma tabela de banco de dados, o mapeamento será seu esquema (ou seja, as definições de seus campos e atributos).
Esse conector oferece suporte à recuperação de metadados da instância do OpenSearch e do AWS Glue Data Catalog. Se o conector encontrar um banco de dados e tabela do AWS Glue que correspondam aos nomes de domínio e índice do OpenSearch, o conector tentará usá-los para definição de esquema. Recomendamos que você crie sua tabela do AWS Glue para que seja um superconjunto de todos os campos em seu índice do OpenSearch.
+ **Documento**: um registro em uma tabela do banco de dados.
+ **Fluxo de dados**: dados baseados em tempo que são compostos por vários índices de apoio. Para obter mais informações, consulte [Fluxos de dados](https://opensearch.org/docs/latest/dashboards/im-dashboards/datastream/) na documentação do OpenSearch e [Conceitos básicos de fluxos de dados](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/data-streams.html#data-streams-example) no *Guia do desenvolvedor do Amazon OpenSearch Service*.
**nota**
Como os índices do fluxo de dados são criados e gerenciados internamente pelo OpenSearch, o conector escolhe o mapeamento do esquema com base no primeiro índice disponível. Por isso, é altamente recomendável configurar uma tabela do AWS Glue como fonte suplementar de metadados. Para obter mais informações, consulte [Configuração de bancos de dados e tabelas no AWS Glue](#connectors-opensearch-setting-up-databases-and-tables-in-aws-glue).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do OpenSearch.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do OpenSearch usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do OpenSearch como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type OPENSEARCH
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do OpenSearch criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do OpenSearch criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue**: (opcional) se estiver presente e definido como verdadeiro, o conector não tentará recuperar metadados complementares do AWS Glue.
+ **query\$1timeout\$1cluster**: o tempo limite, em segundos, para consultas de integridade do cluster usadas na geração de verificações paralelas.
+ **query\$1timeout\$1search**: o tempo limite, em segundos, para consultas de pesquisa usadas na recuperação de documentos de um índice.
+ **auto\$1discover\$1endpoint**: booleano. O padrão é `true`. Quando você usar o Amazon OpenSearch Service e definir esse parâmetro como verdadeiro, o conector poderá descobrir automaticamente seus domínios e endpoints chamando as operações de API de descrição ou lista apropriadas no OpenSearch Service. Para qualquer outro tipo de instância do OpenSearch (por exemplo, auto-hospedada), você deverá especificar os endpoints de domínio associados na variável `domain_mapping`. Se `auto_discover_endpoint=true`, o conector usará credenciais da AWS para se autenticar no OpenSearch Service. Caso contrário, o conector recuperará as credenciais de nome de usuário e senha do AWS Secrets Manager por meio da variável `domain_mapping`.
+ **domain\$1mapping**: usado somente quando `auto_discover_endpoint` for definido como falso, e estabelece o mapeamento entre nomes de domínio e seus endpoints associados. A variável `domain_mapping` pode acomodar vários endpoints do OpenSearch no formato a seguir:
```
domain1=endpoint1,domain2=endpoint2,domain3=endpoint3,...
```
Para fins de autenticação em um endpoint do OpenSearch, o conector oferece suporte a strings de substituição injetadas usando o formato `${SecretName}` com nome de usuário e senha recuperados do AWS Secrets Manager. O segredo deve ser armazenado no seguinte formato JSON:
```
{ "username": "your_username", "password": "your_password" }
```
O conector analisará automaticamente essa estrutura JSON para recuperar as credenciais.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
O exemplo a seguir usa o segredo `opensearch-creds`.
```
movies=https://${opensearch-creds}:search-movies-ne...qu---us-east-1---es.amazonaws.com
```
Em runtime, `${opensearch-creds}` será renderizado como nome de usuário e senha, como no exemplo a seguir.
```
movies=https://myusername@mypassword:search-movies-ne...qu---us-east-1---es.amazonaws.com
```
No parâmetro `domain_mapping`, cada par de domínio e endpoint pode usar um segredo diferente. O segredo em si deve ser especificado no formato *nome\$1do\$1usuário*@*senha*. Embora a senha possa conter sinais `@` incorporados, o primeiro `@` serve como um separador de *nome\$1do\$1usuário*.
Também é importante observar que a vírgula (,) e o sinal de igual (=) são usados por esse conector como separadores para os pares de endpoints do domínio. Por esse motivo, você não deve usá-los em nenhum lugar do segredo armazenado.
## Configuração de bancos de dados e tabelas no AWS Glue
O conector obtém informações de metadados usando o AWS Glue ou o OpenSearch. É possível configurar uma tabela do AWS Glue como fonte de definição de metadados complementar. Para ativar esse recurso, defina um banco de dados do AWS Glue e uma tabela que correspondam ao domínio e ao índice da fonte que você está complementando. O conector também pode aproveitar as definições de metadados armazenadas na instância do OpenSearch recuperando o mapeamento para o índice especificado.
### Definição de metadados para matrizes no OpenSearch
O OpenSearch não tem um tipo de dados de matriz dedicado. Qualquer campo pode conter zero ou mais valores, desde que sejam do mesmo tipo de dados. Se você quiser usar o OpenSearch como sua fonte de definição de metadados, você deve definir uma propriedade `_meta` para todos os índices usados com o Athena para os campos que devam ser considerados uma lista ou matriz. Se você não conseguir concluir essa etapa, as consultas retornarão somente o primeiro elemento no campo da lista. Quando você especificar a propriedade `_meta`, os nomes dos campos deverão ser totalmente qualificados para estruturas JSON aninhadas (por exemplo, `address.street`, em que `street` é um campo aninhado dentro de uma estrutura `address`).
O exemplo a seguir define as listas `actor` e `genre` na tabela `movies`.
```
PUT movies/_mapping
{
"_meta": {
"actor": "list",
"genre": "list"
}
}
```
### Tipos de dados
O conector OpenSearch pode extrair definições de metadados do AWS Glue ou da instância do OpenSearch. O conector usa o mapeamento na tabela a seguir para converter as definições em tipos de dados do Apache Arrow, incluindo os pontos indicados na seção a seguir.
****
| OpenSearch | Apache Arrow | AWS Glue |
| --- | --- | --- |
| text, keyword, binary | VARCHAR | string |
| longo | BIGINT | bigint |
| scaled\$1float | BIGINT | SCALED\$1FLOAT(...) |
| integer | INT | int |
| curto | SMALLINT | smallint |
| byte | TINYINT | tinyint |
| double | FLOAT8 | double |
| float, half\$1float | FLOAT4 | flutuação |
| booleano | BIT | booleano |
| date, date\$1nanos | DATEMILLI | timestamp |
| Estrutura JSON | STRUCT | STRUCT |
| \$1meta (para obter mais informações, consulte a seção [Definição de metadados para matrizes no OpenSearch](#connectors-opensearch-defining-metadata-for-arrays-in-opensearch).) | LIST | ARRAY |
#### Notas sobre tipos de dados
+ No momento, o conector oferece suporte somente os tipos de dados do OpenSearch e do AWS Glue listados na tabela anterior.
+ Um `scaled_float` é um número de ponto flutuante escalado por um fator fixo de escala dupla e representado como um `BIGINT` no Apache Arrow. Por exemplo, 0,756 com um fator de escala de 100 é arredondado para 76.
+ Para definir um `scaled_float` no AWS Glue, você deverá selecionar o tipo de coluna `array` e declarar o campo usando o formato SCALED\$1FLOAT(*fator\$1de\$1escala*).
Os exemplos a seguir são válidos:
```
SCALED_FLOAT(10.51)
SCALED_FLOAT(100)
SCALED_FLOAT(100.0)
```
Os exemplos a seguir não são válidos:
```
SCALED_FLOAT(10.)
SCALED_FLOAT(.5)
```
+ Ao converter de `date_nanos` para `DATEMILLI`, os nanossegundos serão arredondados para o milissegundo mais próximo. Valores válidos para `date` e `date_nanos` incluem, entre outros, os seguintes formatos:
```
"2020-05-18T10:15:30.123456789"
"2020-05-15T06:50:01.123Z"
"2020-05-15T06:49:30.123-05:00"
1589525370001 (epoch milliseconds)
```
+ Um `binary` do OpenSearch é uma representação de string de um valor binário codificado usando `Base64`, e é convertido em um `VARCHAR`.
## Execução de consultas de SQL
Veja a seguir exemplos de consultas DDL que você pode usar com esse conector. Nos exemplos, *nome\$1da\$1função* corresponde ao nome da função do Lambda *domínio* é o nome do domínio que você deseja consultar e *índice* é o nome do seu índice.
```
SHOW DATABASES in `lambda:function_name`
```
```
SHOW TABLES in `lambda:function_name`.domain
```
```
DESCRIBE `lambda:function_name`.domain.index
```
## desempenho
O conector OpenSearch do Athena oferece suporte a verificações paralelas baseadas em fragmentos. O conector usa as informações de integridade do cluster recuperadas da instância do OpenSearch para gerar várias solicitações para uma consulta de pesquisa de documentos. As solicitações são divididas para cada fragmento e executadas simultaneamente.
O conector também reduz os predicados como parte de suas consultas de pesquisa de documentos. O exemplo de consulta e predicado a seguir mostra como o conector usa a redução de predicado.
**Consulta**
```
SELECT * FROM "lambda:elasticsearch".movies.movies
WHERE year >= 1955 AND year <= 1962 OR year = 1996
```
**Predicado**
```
(_exists_:year) AND year:([1955 TO 1962] OR 1996)
```
## Consultas de passagem
O conector OpenSearch é compatível com [consultas de passagem](federated-query-passthrough.md) e usa a linguagem Query DSL. Para obter mais informações sobre consultas com o Query DSL, consulte [Query DSL](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html) na documentação do Elasticsearch ou [Query DSL](https://opensearch.org/docs/latest/query-dsl/) na documentação do OpenSearch.
Para usar as consultas de passagem com o conector OpenSearch, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
schema => 'schema_name',
index => 'index_name',
query => "{query_string}"
))
```
O seguinte exemplo de consulta de passagem do OpenSearch filtra funcionários com status de emprego ativo no índice `employee` do esquema `default`.
```
SELECT * FROM TABLE(
system.query(
schema => 'default',
index => 'employee',
query => "{ ''bool'':{''filter'':{''term'':{''status'': ''active''}}}}"
))
```
## Recursos adicionais
+ Para ver um artigo sobre o uso do conector Amazon Athena OpenSearch para consultar dados no Amazon OpenSearch Service e no Amazon S3 em uma única consulta, consulte [Consulte dados no Amazon OpenSearch Service usando SQL do Amazon Athena](https://aws.amazon.com/blogs/big-data/query-data-in-amazon-opensearch-service-using-sql-from-amazon-athena/) no *Blog de Big Data da AWS*.
+ Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-elasticsearch) em GitHub.com.
# Conector do Amazon Athena para Oracle
O conector do Amazon Athena para Oracle permite que o Amazon Athena execute consultas SQL em dados armazenados no Oracle em execução on-premises, no Amazon EC2 ou no Amazon RDS. Você também pode usar o conector para consultar dados no [Oracle Exadata](https://www.oracle.com/engineered-systems/exadata/).
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Há suporte somente à versão 12.1.0.2 do Oracle Databases.
+ Se o conector do Oracle não usar uma conexão do Glue, os nomes do banco de dados, da tabela e da coluna serão convertidos em maiúsculas pelo conector.
Se o conector do Oracle usar uma conexão do Glue, os nomes do banco de dados, da tabela e da coluna não serão convertidos em maiúsculas pelo conector. Para alterar esse comportamento de maiúsculas e minúsculas, altere o Lambda pela variável de ambiente `casing_mode` para `upper` ou `lower` conforme necessário.
Um conector Oracle usando uma conexão do Glue não é compatível com o uso de um manipulador de multiplexação.
+ Quando o Oracle `NUMBER` for usado sem Precisão e Escala definidos, o Athena irá tratá-lo como `BIGINT`. Para obter as casas decimais necessárias no Athena, especifique `default_scale=` nas variáveis de ambiente da sua função do Lambda.
## Termos
Os termos a seguir estão relacionados ao conector Oracle.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Oracle.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Oracle usando um objeto de conexões do Glue. Para tal, defina a variável de ambiente `glue_connection` do Lambda do conector Oracle como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type ORACLE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **is\$1fips\$1enabled**: (opcional) defina como true quando o modo FIPS estiver habilitado. O padrão é falso.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que não têm uma conexão do Glue associada.
+ **case\$1insensitive\$1search**: executa pesquisas sem diferenciar maiúsculas de minúsculas em nomes de esquemas e tabelas no Oracle. Use esse valor se sua consulta contiver nomes de esquema ou tabela que não correspondam ao padrão de maiúsculas e minúsculas do seu conector.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Oracle criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Oracle criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **default**: uma string de conexão JDBC a ser usada para conexão com a instância do banco de dados Oracle. Por exemplo, ., `oracle://${jdbc_connection_string}`
+ **catalog\$1connection\$1string**: usada pelo manipulador de multiplexação (não compatível com o uso de uma conexão do Glue). Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myoraclecatalog, então o nome da variável de ambiente será myoraclecatalog\$1connection\$1string.
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **is\$1fips\$1enabled**: (opcional) defina como true quando o modo FIPS estiver habilitado. O padrão é falso.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que não têm uma conexão do Glue associada.
+ **case\$1insensitive\$1search**: executa pesquisas sem diferenciar maiúsculas de minúsculas em nomes de esquemas e tabelas no Oracle. Use esse valor se sua consulta contiver nomes de esquema ou tabela que não correspondam ao padrão de maiúsculas e minúsculas do seu conector.
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
oracle://${jdbc_connection_string}
```
**nota**
Se sua senha contiver caracteres especiais (por exemplo, `some.password`), coloque-a entre aspas duplas quando passá-la para a string de conexão (por exemplo, `"some.password"`). Não fazê-lo pode resultar em um erro de URL inválido especificado.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Oracle.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | OracleCompositeHandler |
| Manipulador de metadados | OracleMetadataHandler |
| Manipulador de registros | OracleRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
| IsFIPSEnabled | Opcional. Definido como true quando o modo FIPS estiver ativado. O padrão é false. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O conector oferece suporte a conexões baseadas em SSL a instâncias do Amazon RDS. O suporte é limitado ao protocolo Transport Layer Security (TLS) e à autenticação do servidor pelo cliente. Não há suporte para a autenticação mútua no Amazon RDS. A segunda linha na tabela abaixo mostra a sintaxe para o uso de SSL.
O exemplo de propriedade a seguir é para uma única instância do Oracle com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle\$1@//hostname:port/servicename |
| | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle\$1@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS) (HOST=)(PORT=))(CONNECT\$1DATA=(SID=))(SECURITY=(SSL\$1SERVER\$1CERT\$1DN=))) |
#### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**nota**
Se sua senha contiver caracteres especiais (por exemplo, `some.password`), coloque-a entre aspas duplas quando armazená-la no Secrets Manager (por exemplo, `"some.password"`). Não fazê-lo pode resultar em um erro de URL inválido especificado.
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/Oracle}`.
```
oracle://jdbc:oracle:thin:${Test/RDS/Oracle}@//hostname:port/servicename
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
oracle://jdbc:oracle:thin:username/password@//hostname:port/servicename
```
Atualmente, o conector Oracle reconhece as propriedades `UID` e `PWD` do JDBC.
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | OracleMuxCompositeHandler |
| Manipulador de metadados | OracleMuxMetadataHandler |
| Manipulador de registros | OracleMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myoraclecatalog, então o nome da variável de ambiente será myoraclecatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Oracle que ofereça suporte a duas instâncias de banco de dados: `oracle1` (o padrão) e `oracle2`.
****
| Propriedade | Valor |
| --- | --- |
| default | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle1\$1@//oracle1.hostname:port/servicename |
| oracle\$1catalog1\$1connection\$1string | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle1\$1@//oracle1.hostname:port/servicename |
| oracle\$1catalog2\$1connection\$1string | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle2\$1@//oracle2.hostname:port/servicename |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC, do Oracle e do Arrow.
****
| JDBC | Oracle | Arrow |
| --- | --- | --- |
| Booleano | booleano | Bit |
| Inteiro | N/D | Tiny |
| Short | smallint | Smallint |
| Inteiro | integer | Int |
| Longo | bigint | Bigint |
| flutuação | float4 | Float4 |
| Duplo | float8 | Float8 |
| Data | date | Data/Dia |
| Timestamp | timestamp | Date Milli |
| String | texto | Varchar |
| Bytes | bytes | Varbinary |
| BigDecimal | numeric(p,s) | Decimal |
| ARRAY | N/D (ver nota) | Lista |
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O Oracle oferece suporte a partições nativas. O conector do Athena para o Oracle pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento nativo é altamente recomendado. A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector Oracle é resiliente ao controle de utilização devido à simultaneidade. No entanto, os tempos de execução das consultas tendem a ser longos.
O conector do Athena para Oracle realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. Predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Oracle pode combinar essas expressões e passá-las diretamente ao Oracle para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Oracle são compatíveis com a passagem de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Consultas de passagem
O conector Oracle é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Oracle, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Oracle. A consulta seleciona todas as colunas na tabela `customer`.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/pom.xml) do conector Oracle em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-oracle) em GitHub.com.
# Conector do Amazon Athena para o PostgreSQL
O conector PostgreSQL do Amazon Athena permite que o Athena acesse seus bancos de dados PostgreSQL.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Assim como o PostgreSQL, o Athena trata os espaços à direita nos tipos `CHAR` do PostgreSQL como semanticamente insignificantes para fins de comprimento e comparação. Observe que isso se aplica somente aos tipos `CHAR`, mas não aos `VARCHAR`. O Athena ignora os espaços à direita no tipo `CHAR`, mas os trata como significativos para no `VARCHAR`.
+ Quando você usa o tipo de dados de cadeia de caracteres [citext](https://www.postgresql.org/docs/current/citext.html) que não diferencia maiúsculas de minúsculas, o PostgreSQL usa uma comparação de dados sem distinção entre maiúsculas e minúsculas que é diferente do Athena. Essa diferença cria uma discrepância de dados durante as operações SQL`JOIN`. Para contornar esse problema, use o recurso de consultas de passagem do conector do PostgreSQL. Para ter mais informações, veja a seção [Consultas de passagem](#connectors-postgres-passthrough-queries) posteriormente neste documento.
## Termos
Os termos a seguir estão relacionados ao conector PostgreSQL.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do PostgreSQL.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do PostgreSQL usando um objeto de conexão do Glue.
Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do PostgreSQL com o nome da conexão do Glue que deseja usar.
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type POSTGRESQL
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do PostgreSQL criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do PostgreSQL criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
postgres://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | PostGreSqlMuxCompositeHandler |
| Manipulador de metadados | PostGreSqlMuxMetadataHandler |
| Manipulador de registros | PostGreSqlMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mypostgrescatalog, então o nome da variável de ambiente será mypostgrescatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do PostgreSQL que ofereça suporte a duas instâncias de banco de dados: `postgres1` (o padrão) e `postgres2`.
****
| Propriedade | Valor |
| --- | --- |
| default | postgres://jdbc:postgresql://postgres1.host:5432/default?\$1\$1Test/RDS/PostGres1\$1 |
| postgres\$1catalog1\$1connection\$1string | postgres://jdbc:postgresql://postgres1.host:5432/default?\$1\$1Test/RDS/PostGres1\$1 |
| postgres\$1catalog2\$1connection\$1string | postgres://jdbc:postgresql://postgres2.host:5432/default?user=sample&password=sample |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/PostGres1}`.
```
postgres://jdbc:postgresql://postgres1.host:5432/default?...&${Test/RDS/PostGres1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
postgres://jdbc:postgresql://postgres1.host:5432/default?...&user=sample2&password=sample2&...
```
Atualmente, o conector PostgreSQL reconhece as propriedades `user` e `password` do JDBC.
##### Habilitação do SSL
Para oferecer suporte a SSL em sua conexão PostgreSQL, acrescente o seguinte à string de conexão:
```
&sslmode=verify-ca&sslfactory=org.postgresql.ssl.DefaultJavaSSLFactory
```
**Exemplo**
O exemplo de string de conexão a seguir não usa SSL.
```
postgres://jdbc:postgresql://example-asdf-aurora-postgres-endpoint:5432/asdf?user=someuser&password=somepassword
```
Para habilitar o SSL, modifique a string da forma mostrada a seguir.
```
postgres://jdbc:postgresql://example-asdf-aurora-postgres-endpoint:5432/asdf?user=someuser&password=somepassword&sslmode=verify-ca&sslfactory=org.postgresql.ssl.DefaultJavaSSLFactory
```
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do PostgreSQL.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | PostGreSqlCompositeHandler |
| Manipulador de metadados | PostGreSqlMetadataHandler |
| Manipulador de registros | PostGreSqlRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do PostgreSQL com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | postgres://jdbc:postgresql://postgres1.host:5432/default?secret=\$1\$1Test/RDS/PostgreSQL1\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC, do PostgreSQL e do Arrow.
****
| JDBC | PostGreSQL | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Inteiro | N/D | Tiny |
| Short | smallint | Smallint |
| Inteiro | integer | Int |
| Longo | bigint | Bigint |
| flutuação | float4 | Float4 |
| Duplo | float8 | Float8 |
| Data | date | Data/Dia |
| Timestamp | timestamp | Date Milli |
| String | texto | Varchar |
| Bytes | bytes | Varbinary |
| BigDecimal | numeric(p,s) | Decimal |
| ARRAY | N/D (ver nota) | Lista |
**nota**
Há suporte para o tipo `ARRAY` no conector PostgreSQL com as seguintes restrições: não há suporte para matrizes multidimensionais (`[][]` ou matrizes aninhadas). Colunas com tipos de dados `ARRAY` sem suporte serão convertidas em uma matriz de elementos de string (`array`).
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
## desempenho
O PostgreSQL oferece suporte a partições nativas. O conector do Athena para o PostgreSQL pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento nativo é altamente recomendado.
O conector do Athena para o PostgreSQL executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta. Porém, selecionar um subconjunto de colunas resulta, algumas vezes, em um runtime mais longo.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o PostgreSQL pode combinar essas expressões e passá-las diretamente ao PostgreSQL para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o PostgreSQL são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector PostgreSQL é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o PostgreSQL, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no PostgreSQL. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-postgresql/pom.xml) do conector PostgreSQL em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-postgresql) em GitHub.com.
# Conector do Amazon Athena para Redis OSS
O conector do Redis OSS no Amazon Athena permite que o Amazon Athena se comunique com as instâncias do Redis OSS para que você possa consultar os dados do Redis OSS com SQL. É possível usar o AWS Glue Data Catalog para mapear os pares de chave-valor do Redis OSS em tabelas virtuais.
Ao contrário dos armazenamentos de dados relacionais tradicionais, o Redis OSS não tem o conceito de tabela ou coluna. Em vez disso, o Redis OSS oferece padrões de acesso de valores-chave em que a chave é essencialmente uma `string` e o valor é uma `string`, `z-set` ou `hmap`.
É possível usar o AWS Glue Data Catalog para criar um esquema e configurar tabelas virtuais. As propriedades especiais da tabela informam ao conector do Redis OSS do Athena como mapear suas chaves e valores do Redis OSS em uma tabela. Para obter mais informações, consulte [Configuração de bancos de dados e tabelas no AWS Glue](#connectors-redis-setting-up-databases-and-tables-in-glue) adiante neste documento.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
O conector do Amazon Athena para o Redis OSS oferece suporte ao Amazon MemoryDB e ao Amazon ElastiCache (Redis OSS).
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Redis.
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar o desempenho, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
## Configuração de bancos de dados e tabelas no AWS Glue
Para habilitar uma tabela do AWS Glue para uso com o Redis OSS, é possível definir as seguintes propriedades da tabela na tabela: `redis-endpoint`, `redis-value-type` e `redis-keys-zset` ou `redis-key-prefix`.
Além disso, qualquer banco de dados do AWS Glue que contenha tabelas do Redis OSS deve ter um `redis-db-flag` na propriedade URI do banco de dados. Para definir a propriedade da URI `redis-db-flag`, use o console do AWS Glue para editar o banco de dados.
A lista a seguir descreve as propriedades da tabela.
+ **redis-endpoint**: (obrigatório) o *nome do host*`:`*porta*`:`*senha* do servidor Redis que contém dados para essa tabela (por exemplo, `athena-federation-demo.cache.amazonaws.com:6379`). Como alternativa, é possível armazenar o endpoint, ou parte do endpoint, em AWS Secrets Manager, usando \$1\$1*Secret\$1Name*\$1 como o valor da propriedade da tabela.
**nota**
Para usar o recurso de consulta federada do Athena com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
+ **redis-keys-zset**: (necessário se `redis-key-prefix` não for usado) uma lista separada por vírgulas de chaves cujo valor é um [zset](https://redis.com/ebook/part-2-core-concepts/chapter-3-commands-in-redis/3-5-sorted-sets/) (por exemplo, `active-orders,pending-orders`). Cada um dos valores no zset é tratado como uma chave que faz parte da tabela. A propriedade `redis-keys-zset` ou a propriedade `redis-key-prefix` devem ser definidas.
+ **redis-key-prefix**: (necessário se `redis-keys-zset` não for usado) uma lista separada por vírgulas de prefixos de chave para verificar os valores na tabela (por exemplo, `accounts-*,acct-`). A propriedade `redis-key-prefix` ou a propriedade `redis-keys-zset` devem ser definidas.
+ **redis-value-type**: (obrigatório) define como os valores das chaves definidos por `redis-key-prefix` ou `redis-keys-zset` são mapeados para sua tabela. Um literal é mapeado para uma única coluna. Um zset também é mapeado para uma única coluna, mas cada chave pode armazenar muitas linhas. Um hash permite que cada chave seja uma linha com várias colunas (por exemplo, um hash, literal ou zset).
+ **redis-ssl-flag**: (opcional) quando for `True`, cria uma conexão Redis que usa SSL/TLS. O padrão é `False`.
+ **redis-cluster-flag**: (opcional) quando for `True`, permite o suporte para instâncias Redis em cluster. O padrão é `False`.
+ **redis-db-number**: (opcional) aplica-se somente a instâncias autônomas sem cluster. Defina esse número (por exemplo, 1, 2 ou 3) para ler de um banco de dados Redis não padrão. O padrão é o banco de dados lógico Redis 0. Esse número não se refere a um banco de dados no Athena ou no AWS Glue, mas a um banco de dados lógico Redis. Para obter mais informações, consulte [Índice SELECT](https://redis.io/commands/select) na documentação do Redis.
## Tipos de dados
O conector Redis OSS é compatível com os tipos de dados a seguir. Os fluxos do Redis OSS não são compatíveis.
+ [String](https://redis.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/1-2-1-strings-in-redis/)
+ [Hash](https://redis.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/1-2-4-hashes-in-redis/)
+ Conjunto classificados ([ZSet](https://redis.com/ebook/part-2-core-concepts/chapter-3-commands-in-redis/3-5-sorted-sets/))
Todos os valores do Redis OSS são recuperados como o tipo de dados `string`. Em seguida, eles são convertidos em um dos seguintes tipos de dados do Apache Arrow, com base em como suas tabelas são definidas no AWS Glue Data Catalog.
****
| AWS GlueTipo de dados do | Tipo de dados Apache Arrow |
| --- | --- |
| int | INT |
| string | VARCHAR |
| bigint | BIGINT |
| double | FLOAT8 |
| flutuação | FLOAT4 |
| smallint | SMALLINT |
| tinyint | TINYINT |
| booleano | BIT |
| binary | VARBINARY |
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-redis.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-redis/athena-redis.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector do Redis requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
+ **Acesso de leitura do AWS Secrets Manager**: se você optar por armazenar os detalhes do endpoint do Redis no Secrets Manager, deverá conceder ao conector acesso a esses segredos.
+ **Acesso à VPC**: o conector exige a capacidade de conectar e desconectar interfaces à sua VPC para que possa se conectar a ela e se comunicar com suas instâncias do Redis.
## desempenho
O conector do Redis OSS para o Athena tenta paralelizar as consultas com sua instância do Redis OSS de acordo com o tipo de tabela que você definiu (por exemplo, chaves zset ou chaves de prefixo).
O conector do Athena para Redis realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. No entanto, as consultas que contêm um predicado na chave primária apresentam falhas relacionadas ao tempo limite. As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados. O conector Redis é resiliente ao controle de utilização devido à simultaneidade.
## Consultas de passagem
O conector Redis é compatível com [consultas de passagem](federated-query-passthrough.md). Você pode usar esse atributo para executar consultas que usam um script Lua em bancos de dados Redis.
Para usar consultas de passagem com o Redis, use a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.script(
script => 'return redis.[call|pcall](query_script)',
keys => '[key_pattern]',
argv => '[script_arguments]'
))
```
O exemplo a seguir executa um script Lua para obter o valor na chave `l:a`.
```
SELECT * FROM TABLE(
system.script(
script => 'return redis.call("GET", KEYS[1])',
keys => '[l:a]',
argv => '[]'
))
```
## Informações de licença
O projeto do conector do Redis do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-redis) em GitHub.com.
# Conector do Amazon Athena para o Redshift
O conector Redshift do Amazon Athena permite que o Amazon Athena acesse bancos de dados do Amazon Redshift e do Amazon Redshift sem servidor, incluindo visualizações do RedShift sem servidor. Você pode se conectar a qualquer serviço usando as configurações da string de conexão JDBC descritas nesta página.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Como o Redshift não oferece suporte a partições externas, todos os dados especificados por uma consulta são recuperados sempre.
+ Assim como o Redshift, o Athena trata os espaços à direita nos tipos `CHAR` do Redshift como semanticamente insignificantes para fins de comprimento e comparação. Observe que isso se aplica somente aos tipos `CHAR`, mas não aos `VARCHAR`. O Athena ignora os espaços à direita no tipo `CHAR`, mas os trata como significativos para no `VARCHAR`.
## Termos
Os termos a seguir estão relacionados ao conector Redshift.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Redshift.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Redshift usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Redshift com o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type REDSHIFT
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Redshift criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Redshift criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue**: (opcional) se estiver presente e definido como verdadeiro, o conector não tentará recuperar metadados complementares do AWS Glue.
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
redshift://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | RedshiftMuxCompositeHandler |
| Manipulador de metadados | RedshiftMuxMetadataHandler |
| Manipulador de registros | RedshiftMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myredshiftcatalog, então o nome da variável de ambiente será myredshiftcatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades do exemplo a seguir são para uma função do Lambda MUX do Redshift que ofereça suporte a duas instâncias de banco de dados: `redshift1` (o padrão) e `redshift2`.
****
| Propriedade | Valor |
| --- | --- |
| default | redshift://jdbc:redshift://redshift1.host:5439/dev?user=sample2&password=sample2 |
| redshift\$1catalog1\$1connection\$1string | redshift://jdbc:redshift://redshift1.host:3306/default?\$1\$1Test/RDS/Redshift1\$1 |
| redshift\$1catalog2\$1connection\$1string | redshift://jdbc:redshift://redshift2.host:3333/default?user=sample2&password=sample2 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto \$1\$1Test/RDS/ `Redshift1`\$1.
```
redshift://jdbc:redshift://redshift1.host:3306/default?...&${Test/RDS/Redshift1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
redshift://jdbc:redshift://redshift1.host:3306/default?...&user=sample2&password=sample2&...
```
Atualmente, o conector do Redshift reconhece as propriedades `user` e `password` do JDBC.
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Inteiro | Tiny |
| Short | Smallint |
| Inteiro | Int |
| Longo | Bigint |
| flutuação | Float4 |
| Duplo | Float8 |
| Data | Data/Dia |
| Timestamp | Date Milli |
| String | Varchar |
| Bytes | Varbinary |
| BigDecimal | Decimal |
| ARRAY | Lista |
## Partições e divisões
O Redshift não oferece suporte a partições externas. Para obter mais informações sobre problemas relativos à performance, consulte [desempenho](#connectors-redshift-performance).
## desempenho
O conector do Athena para o Redshift executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, cláusulas `ORDER BY`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta. Porém, selecionar um subconjunto de colunas resulta, algumas vezes, em um runtime mais longo. O Amazon Redshift é particularmente suscetível à lentidão na execução de consultas quando você executa várias consultas simultaneamente.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Principais N consultas
Uma das `N` principais consultas especifica uma ordenação do conjunto de resultados e um limite no número de linhas retornadas. Você pode usar esse tipo de consulta para determinar os `N` principais valores máximos ou `N` principais valores mínimos para os conjuntos de dados. Com os `N` pushdown principais, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Redshift pode combinar essas expressões e passá-las diretamente ao Redshift para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Redshift são compatíveis com a passágem de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
ORDER BY col_a DESC
LIMIT 10;
```
Para ver um artigo sobre como usar o pushdown de predicado para melhorar a performance em consultas federadas, incluindo Amazon Redshift, consulte [Melhorar as consultas federadas com o pushdown de predicados no Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) no *Blog de Big Data da AWS*.
## Consultas de passagem
O conector Redshift é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Redshift, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Redshift. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-redshift/pom.xml) do conector do Redshift em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-redshift) em GitHub.com.
# Conector do Amazon Athena para o SAP HANA
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ No SAP HANA, os nomes dos objetos são convertidos em maiúsculas quando armazenados no banco de dados do SAP HANA. No entanto, como os nomes entre aspas diferenciam maiúsculas e minúsculas, é possível que duas tabelas tenham o mesmo nome em maiúsculas e minúsculas (por exemplo, `EMPLOYEE` e `employee`).
Na Athena Federated Query, os nomes das tabelas de esquema são fornecidos para a função do Lambda em letras minúsculas. Para resolver esse problema, é possível fornecer dicas de consulta `@schemaCase` para recuperar os dados das tabelas que tenham nomes que diferenciem maiúsculas de minúsculas. A seguir estão dois exemplos de consultas com dicas de consulta.
```
SELECT *
FROM "lambda:saphanaconnector".SYSTEM."MY_TABLE@schemaCase=upper&tableCase=upper"
```
```
SELECT *
FROM "lambda:saphanaconnector".SYSTEM."MY_TABLE@schemaCase=upper&tableCase=lower"
```
## Termos
Os termos a seguir estão relacionados ao conector SAP HANA.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do SAP HANA.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do SAP HANA usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do SAP HANA como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type SAPHANA
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do SAP HANA criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do SAP HANA criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
saphana://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | SaphanaMuxCompositeHandler |
| Manipulador de metadados | SaphanaMuxMetadataHandler |
| Manipulador de registros | SaphanaMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mysaphanacatalog, então o nome da variável de ambiente será mysaphanacatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Saphana que ofereça suporte a duas instâncias de banco de dados: `saphana1` (o padrão) e `saphana2`.
****
| Propriedade | Valor |
| --- | --- |
| default | saphana://jdbc:sap://saphana1.host:port/?\$1\$1Test/RDS/ Saphana1\$1 |
| saphana\$1catalog1\$1connection\$1string | saphana://jdbc:sap://saphana1.host:port/?\$1\$1Test/RDS/ Saphana1\$1 |
| saphana\$1catalog2\$1connection\$1string | saphana://jdbc:sap://saphana2.host:port/?user=sample2&password=sample2 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/Saphana1}`.
```
saphana://jdbc:sap://saphana1.host:port/?${Test/RDS/Saphana1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
saphana://jdbc:sap://saphana1.host:port/?user=sample2&password=sample2&...
```
Atualmente, o conector SAP HANA reconhece as propriedades `user` e `password` do JDBC.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do SAP HANA.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | SaphanaCompositeHandler |
| Manipulador de metadados | SaphanaMetadataHandler |
| Manipulador de registros | SaphanaRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância SAP HANA com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | saphana://jdbc:sap://saphana1.host:port/?secret=Test/RDS/Saphana1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Inteiro | Tiny |
| Short | Smallint |
| Inteiro | Int |
| Longo | Bigint |
| flutuação | Float4 |
| Duplo | Float8 |
| Data | Data/Dia |
| Timestamp | Date Milli |
| String | Varchar |
| Bytes | Varbinary |
| BigDecimal | Decimal |
| ARRAY | Lista |
## Conversões de tipos de dados
Além das conversões de JDBC para Arrow, o conector realiza algumas outras conversões para tornar a fonte SAP HANA e os tipos de dados do Athena compatíveis. Essas conversões ajudam a garantir que as consultas sejam executadas com êxito. A tabela a seguir mostra essas conversões:
****
| Tipo de dados de origem (SAP HANA) | Tipo de dados convertidos (Athena) |
| --- | --- |
| DECIMAL | BIGINT |
| INTEGER | INT |
| DATE | DATEDAY |
| TIMESTAMP | DATEMILLI |
Todos os outros tipos de dados sem suporte são convertidos em `VARCHAR`.
## Partições e divisões
Uma partição é representada por uma única coluna de partição do tipo `Integer`. A coluna contém os nomes das partições definidas em uma tabela do SAP HANA. Para uma tabela que não tenha nomes de partição, \$1 será retornado, o que equivale a uma única partição. Uma partição é equivalente a uma divisão.
****
| Nome | Tipo | Descrição |
| --- | --- | --- |
| PART\$1ID | Inteiro | Partição nomeada no SAP HANA. |
## desempenho
O SAP HANA oferece suporte a partições nativas. O conector do Athena para o SAP HANA pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento nativo é altamente recomendado. A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector apresenta um controle de utilização significativo e, às vezes, falhas na consulta devido à simultaneidade.
O conector do Athena para o SAP HANA executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o SAP HANA pode combinar essas expressões e passá-las diretamente ao SAP HANA para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o SAP HANA são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Consultas de passagem
O conector SAP HANA é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o SAP HANA, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no SAP HANA. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/pom.xml) do conector SAP HANA em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-saphana) em GitHub.com.
# Conector o Amazon Athena para o Snowflake
O conector do Amazon Athena para o [Snowflake](https://www.snowflake.com/) permite que o Amazon Athena execute consultas SQL nos dados armazenados no seu banco de dados SQL Snowflake ou em instâncias do RDS usando JDBC.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
Implante o conector na sua Conta da AWS usando o console do Athena ou a operação da API `CreateDataCatalog`. Para obter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Somente conexões legadas são compatíveis com a configuração do multiplexador.
+ No momento, as visualizações do Snowflake com uma única divisão são compatíveis.
+ No Snowflake, os nomes dos objetos diferenciam maiúsculas de minúsculas. O Athena aceita maiúsculas e minúsculas nas consultas DDL e DML, mas, por padrão, converte os nomes dos objetos para [minúsculas](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#table-names-and-table-column-names-in-ate-must-be-lowercase) ao executar a consulta. O conector do Snowflake aceita somente letras minúsculas quando o Catálogo do Glue/Lake Formation é usado. Quando o Catálogo do Athena é usado, os clientes podem controlar o comportamento de diferenciação de maiúsculas e minúsculas usando a variável de ambiente `casing_mode` do Lambda cujos valores possíveis estão listados na seção [Parâmetros](#connectors-snowflake-parameters) (por exemplo, `key=casing_mode, value = CASE_INSENSITIVE_SEARCH`).
## Termos
Os termos a seguir estão relacionados ao conector Snowflake.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Snowflake.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Snowflake usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do Snowflake com o nome da conexão do Glue que deseja usar.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type SNOWFLAKE
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **NONE**: mantém a diferenciação de maiúsculas e minúsculas nos nomes de esquema e tabela (executa a consulta sem modificações no Snowflake). Esse é o valor padrão quando **casing\$1mode** não é especificado.
+ **UPPER**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos na consulta antes de executá-la no Snowflake.
+ **LOWER**: converte para minúsculas todos os nomes de esquema e tabela fornecidos na consulta antes de executá-la no Snowflake.
+ **CASE\$1INSENSITIVE\$1SEARCH**: faz pesquisas sem diferenciar maiúsculas de minúsculas em nomes de esquemas e tabelas no Snowflake. Por exemplo, você pode usar esse modo quando você tem uma consulta como `SELECT * FROM EMPLOYEE` e o Snowflake contém uma tabela chamada `Employee`. No entanto, na presença de duplicidade de nomes, como ter uma tabela chamada `EMPLOYEE` e outra chamada `Employee` no Snowflake, a consulta falhará.
**nota**
O conector do Snowflake criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Snowflake criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
**Armazenar credenciais**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais. Para obter mais informações, consulte [Autenticar com o Snowflake](connectors-snowflake-authentication.md).
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **default**: uma string de conexão JDBC a ser usada para conexão com a instância do banco de dados Snowflake. Por exemplo, ., `snowflake://${jdbc_connection_string}`
+ **catalog\$1connection\$1string**: usada pelo manipulador de multiplexação (não compatível com o uso de uma conexão do Glue). Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mysnowflakecatalog, o nome da variável de ambiente será mysnowflakecatalog\$1connection\$1string.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **NONE**: mantém a diferenciação de maiúsculas e minúsculas nos nomes de esquema e tabela (executa a consulta sem modificações no Snowflake). Esse é o valor padrão quando **casing\$1mode** não é especificado.
+ **UPPER**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos na consulta antes de executá-la no Snowflake.
+ **LOWER**: converte para minúsculas todos os nomes de esquema e tabela fornecidos na consulta antes de executá-la no Snowflake.
+ **CASE\$1INSENSITIVE\$1SEARCH**: faz pesquisas sem diferenciar maiúsculas de minúsculas em nomes de esquemas e tabelas no Snowflake. Por exemplo, você pode usar esse modo quando você tem uma consulta como `SELECT * FROM EMPLOYEE` e o Snowflake contém uma tabela chamada `Employee`. No entanto, na presença de duplicidade de nomes, como ter uma tabela chamada `EMPLOYEE` e outra chamada `Employee` no Snowflake, a consulta falhará.
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
snowflake://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | SnowflakeMuxCompositeHandler |
| Manipulador de metadados | SnowflakeMuxMetadataHandler |
| Manipulador de registros | SnowflakeMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mysnowflakecatalog, então o nome da variável de ambiente será mysnowflakecatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Snowflake que ofereça suporte a duas instâncias de banco de dados: `snowflake1` (o padrão) e `snowflake2`.
****
| Propriedade | Valor |
| --- | --- |
| default | snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1&\$1\$1Test/RDS/Snowflake1\$1 |
| snowflake\$1catalog1\$1connection\$1string | snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1\$1\$1Test/RDS/Snowflake1\$1 |
| snowflake\$1catalog2\$1connection\$1string | snowflake://jdbc:snowflake://snowflake2.host:port/?warehouse=warehousename&db=db1&schema=schema1&user=sample2&password=sample2 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/Snowflake1}`.
```
snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1${Test/RDS/Snowflake1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
snowflake://jdbc:snowflake://snowflake1.host:port/warehouse=warehousename&db=db1&schema=schema1&user=sample2&password=sample2&...
```
Atualmente, o Snowflake reconhece as propriedades `user` e `password` do JDBC. Ele também aceita o nome do usuário e a senha no formato *nome de usuário*`/`*senha* sem as chaves `user` ou `password`.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Snowflake.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | SnowflakeCompositeHandler |
| Manipulador de metadados | SnowflakeMetadataHandler |
| Manipulador de registros | SnowflakeRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Snowflake com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | snowflake://jdbc:snowflake://snowflake1.host:port/?secret=Test/RDS/Snowflake1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Inteiro | Tiny |
| Short | Smallint |
| Inteiro | Int |
| Longo | Bigint |
| flutuação | Float4 |
| Duplo | Float8 |
| Data | Data/Dia |
| Timestamp | Date Milli |
| String | Varchar |
| Bytes | Varbinary |
| BigDecimal | Decimal |
| ARRAY | Lista |
## Conversões de tipos de dados
Além das conversões de JDBC para Arrow, o conector realiza algumas outras conversões para tornar a fonte do Snowflake e os tipos de dados do Athena compatíveis. Essas conversões ajudam a garantir que as consultas sejam executadas com êxito. A tabela a seguir mostra essas conversões:
****
| Tipo de dados de origem (Snowflake) | Tipo de dados convertidos (Athena) |
| --- | --- |
| TIMESTAMP | TIMESTAMPMILLI |
| DATE | TIMESTAMPMILLI |
| INTEGER | INT |
| DECIMAL | BIGINT |
| TIMESTAMP\$1NTZ | TIMESTAMPMILLI |
Todos os outros tipos de dados sem suporte são convertidos em `VARCHAR`.
## Partições e divisões
As partições são usadas para determinar como gerar divisões para o conector. O Athena constrói uma coluna sintética do tipo `varchar` que representa o esquema de particionamento da tabela para ajudar o conector a gerar divisões. O conector não modifica a definição real da tabela.
Para criar essa coluna sintética e as partições, o Athena exige que uma chave primária seja definida. No entanto, como o Snowflake não impõe restrições de chave primária, você mesmo deve impor a exclusividade. Caso você não faça isso, o Athena vai ter como padrão uma divisão única.
## desempenho
Para obter um desempenho ideal, use filtros nas consultas sempre que possível. Além disso, é altamente recomendável o particionamento nativo para recuperar grandes conjuntos de dados com distribuição uniforme de partições. A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector Snowflake é resiliente ao controle de utilização devido à simultaneidade.
O conector do Athena para o Snowflake executa a passagem direta de predicados para diminuir os dados examinados pela consulta. Cláusulas `LIMIT`, predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Cláusulas LIMIT
Uma instrução `LIMIT N` reduz os dados examinados pela consulta. Com a passagem direta de `LIMIT N`, o conector só retorna `N` linhas para o Athena.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Snowflake pode combinar essas expressões e passá-las diretamente ao Snowflake para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Snowflake são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
# Autenticar com o Snowflake
Você pode configurar o conector do Amazon Athena Snowflake para usar a autenticação por par de chaves ou o método de autenticação OAuth para se conectar ao data warehouse do Snowflake. Ambos os métodos fornecem acesso seguro ao Snowflake e eliminam a necessidade de armazenar senhas em cadeias de conexão.
+ **Autenticação por par de chaves**: esse método usa pares de chaves públicas ou privadas RSA para autenticar com o Snowflake. A chave privada assina digitalmente as solicitações de autenticação enquanto a chave pública correspondente é registrada no Snowflake para verificação. Esse método elimina o armazenamento de senhas.
+ **Autenticação OAuth**: esse método usa o token de autorização e o token de atualização para autenticar com o Snowflake. Ele oferece suporte à atualização automática de tokens, o que o torna adequado para aplicações de execução longa.
Para obter mais informações, consulte [autenticação por par de chaves](https://docs.snowflake.com/en/user-guide/key-pair-auth) e [autenticação OAuth](https://docs.snowflake.com/en/user-guide/oauth-custom) no guia do usuário do Snowflake.
## Pré-requisitos
Antes de começar, conclua os seguintes pré-requisitos:
+ Acesso à conta do Snowflake com privilégios administrativos.
+ Conta de usuário do Snowflake dedicada para o conector do Athena.
+ OpenSSL ou ferramentas equivalentes de geração de chaves para autenticação de pares de chaves.
+ Acesso ao AWS Secrets Manager para criar e gerenciar segredos.
+ Navegador da Web para concluir o fluxo do OAuth para a autenticação do OAuth.
## Configurar a autenticação por par de chaves
Esse processo envolve gerar um par de chaves RSA, configurar sua conta do Snowflake com a chave pública e armazenar com segurança a chave privada no AWS Secrets Manager. As etapas a seguir guiarão você na criação das chaves criptográficas, na configuração das permissões necessárias do Snowflake e na configuração das credenciais da AWS para autenticação direta.
1. **Gerar pares de chaves RSA**
Gere um par de chaves pública e privada usando o OpenSSL.
+ Para gerar uma versão não criptografada, use o comando a seguir em sua aplicação de linha de comando local.
```
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
```
+ Para gerar uma versão criptografada, use o comando a seguir, que omite `-nocrypt`.
```
openssl genrsa 2048 | openssl pkcs8 -topk8 -v2 des3 -inform PEM -out rsa_key.p8
```
+ Para gerar uma chave pública com base em uma chave privada.
```
openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub
# Set appropriate permissions (Unix/Linux)
chmod 600 rsa_key.p8
chmod 644 rsa_key.pub
```
**nota**
Não compartilhe sua chave privada. A chave privada só deve estar acessível à aplicação que precisa se autenticar com o Snowflake.
1. **Extrair conteúdo da chave pública sem delimitadores para o Snowflake**
```
# Extract public key content (remove BEGIN/END lines and newlines)
cat rsa_key.pub | grep -v "BEGIN\|END" | tr -d '\n'
```
Salve essa saída, pois ela será necessária mais tarde na próxima etapa.
1. **Configurar um usuário do Snowflake**
Siga estas etapas para configurar um usuário do Snowflake.
1. Crie um usuário dedicado para o conector do Athena, caso ele ainda não exista.
```
-- Create user for Athena connector
CREATE USER athena_connector_user;
-- Grant necessary privileges
GRANT USAGE ON WAREHOUSE your_warehouse TO ROLE athena_connector_role;
GRANT USAGE ON DATABASE your_database TO ROLE athena_connector_role;
GRANT SELECT ON ALL TABLES IN DATABASE your_database TO ROLE athena_connector_role;
```
1. Conceda privilégios de autenticação. Para atribuir uma chave pública a um usuário, é necessário ter um dos seguintes perfis ou privilégios.
+ O privilégio `MODIFY PROGRAMMATIC AUTHENTICATION METHODS` ou `OWNERSHIP` no usuário.
+ O perfil `SECURITYADMIN` ou superior.
Conceda os privilégios necessários para atribuir chaves públicas usando o comando a seguir.
```
GRANT MODIFY PROGRAMMATIC AUTHENTICATION METHODS ON USER athena_connector_user TO ROLE your_admin_role;
```
1. Atribua a chave pública ao usuário do Snowflake usando o comando a seguir.
```
ALTER USER athena_connector_user SET RSA_PUBLIC_KEY='RSAkey';
```
Verifique se a chave pública foi atribuída com sucesso ao usuário com o comando a seguir.
```
DESC USER athena_connector_user;
```
1. **Armazenar a chave privada em AWS Secrets Manager**
1. Converta a chave privada para o formato exigido pelo conector.
```
# Read private key content
cat rsa_key.p8
```
1. Crie um segredo no AWS Secrets Manager com a estrutura a seguir.
```
{
"sfUser": "your_snowflake_user",
"pem_private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----",
"pem_private_key_passphrase": "passphrase_in_case_of_encrypted_private_key(optional)"
}
```
**nota**
O cabeçalho e o rodapé são opcionais.
A chave privada deve ser separada por `\n`.
## Configurar autenticação do OAuth
Esse método de autenticação permite acesso seguro e baseado em tokens ao Snowflake com recursos de atualização automática de credenciais. O processo de configuração envolve a criação de uma integração de segurança no Snowflake, a recuperação das credenciais do cliente OAuth, a conclusão do fluxo de autorização necessário para obter um código de acesso e o armazenamento das credenciais do OAuth no AWS Secrets Manager para uso do conector.
1. **Criar uma integração de segurança no Snowflake**
Execute o seguinte comando SQL no Snowflake para criar uma integração de segurança OAuth do Snowflake.
```
CREATE SECURITY INTEGRATION my_snowflake_oauth_integration_a
TYPE = OAUTH
ENABLED = TRUE
OAUTH_CLIENT = CUSTOM
OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'
OAUTH_REDIRECT_URI = 'https://localhost:8080/oauth/callback'
OAUTH_ISSUE_REFRESH_TOKENS = TRUE
OAUTH_REFRESH_TOKEN_VALIDITY = 7776000;
```
**Parâmetros de configuração**
+ `TYPE = OAUTH`: especifica o tipo de autenticação OAuth.
+ `ENABLED = TRUE`: permite a integração de segurança.
+ `OAUTH_CLIENT = CUSTOM`: usa a configuração personalizada do cliente OAuth.
+ `OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'`: define o tipo de cliente para aplicações seguras.
+ `OAUTH_REDIRECT_URI`: o URL de retorno de chamada para o fluxo do OAuth. Para fins de teste, ele pode ser o localhost.
+ `OAUTH_ISSUE_REFRESH_TOKENS = TRUE`: habilita a geração de tokens de atualização.
+ `OAUTH_REFRESH_TOKEN_VALIDITY = 7776000`: define a validade do token de atualização (90 dias em segundos).
1. **Recuperar segredos do cliente OAuth**
1. Execute o comando SQL a seguir para obter as credenciais do cliente.
```
DESC SECURITY INTEGRATION 'MY_SNOWFLAKE_OAUTH_INTEGRATION_A';
```
1. Recupere os segredos do cliente OAuth.
```
SELECT SYSTEM$SHOW_OAUTH_CLIENT_SECRETS('MY_SNOWFLAKE_OAUTH_INTEGRATION_A');
```
**Exemplo de resposta**
```
{
"OAUTH_CLIENT_SECRET_2": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"OAUTH_CLIENT_SECRET": "je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY,
"OAUTH_CLIENT_ID": "AIDACKCEVSQ6C2EXAMPLE"
}
```
**nota**
Mantenha essas credenciais em segurança e não as compartilhe. Elas serão usadas para configurar o cliente OAuth.
1. **Autorizar o usuário e recuperar o código de autorização**
1. Abra o URL a seguir no seu navegador.
```
https://.snowflakecomputing.com/oauth/authorize?client_id=&response_type=code&redirect_uri=https://localhost:8080/oauth/callback
```
1. Conclua o fluxo de autorização.
1. Faça login usando suas credenciais do Snowflake.
1. Conceda as permissões solicitadas. Você será redirecionado para o URI de retorno de chamada com um código de autorização.
1. Extraia o código de autorização copiando o parâmetro de código do URL de redirecionamento.
```
https://localhost:8080/oauth/callback?code=
```
**nota**
O código de autorização é válido por tempo limitado e só pode ser usado uma vez.
1. **Armazenar credenciais do OAuth no AWS Secrets Manager**
Crie um segredo no AWS Secrets Manager com a estrutura a seguir.
```
{
"redirect_uri": "https://localhost:8080/oauth/callback",
"client_secret": "je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY",
"token_url": "https://.snowflakecomputing.com/oauth/token-request",
"client_id": "AIDACKCEVSQ6C2EXAMPLE,
"username": "your_snowflake_username",
"auth_code": "authorizationcode"
}
```
**Campos obrigatórios**
+ `redirect_uri`: URI de redirecionamento do OAuth que você obteve na Etapa 1.
+ `client_secret`: segredo do cliente OAuth que você obteve na Etapa 2.
+ `token_url`: Snowflake. O endpoint do token OAuth.
+ `client_id`: o ID do cliente OAuth da Etapa 2.
+ `username`: o nome de usuário do Snowflake para o conector.
+ `auth_code`: o código de autorização que você obteve na Etapa 3.
Após criar um segredo, você obtém um ARN de segredo que pode ser usado na sua conexão do Glue ao [criar uma conexão de fonte de dados](connect-to-a-data-source.md).
## Consultas de passagem
O conector Snowflake é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Snowflake, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Snowflake. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/pom.xml) do conector Snowflake em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-snowflake) em GitHub.com.
# Conector do Amazon Athena para o Microsoft SQL Server
O conector do Amazon Athena para o [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/?view=sql-server-ver15) permite que o Amazon Athena execute consultas SQL em dados armazenados no Microsoft SQL Server usando JDBC.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Em condições de filtro, você deve converter os tipos de dados `Date` e `Timestamp` para o tipo de dados apropriado.
+ Para pesquisar valores negativos dos tipos `Real` e `Float`, use o operador `<=` ou `>=`.
+ Não há suporte para os tipos de dados `binary`, `varbinary`, `image` e `rowversion`.
## Termos
Os termos a seguir estão relacionados ao conector SQL Server.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do SQL Server.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do SQL Server usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` do Lambda do conector do SQL Server com o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type SQLSERVER
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do SQL Server criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do SQL Server criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
sqlserver://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | SqlServerMuxCompositeHandler |
| Manipulador de metadados | SqlServerMuxMetadataHandler |
| Manipulador de registros | SqlServerMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for mysqlservercatalog, então o nome da variável de ambiente será mysqlservercatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do SqlServer que ofereça suporte a duas instâncias de banco de dados: `sqlserver1` (o padrão) e `sqlserver2`.
****
| Propriedade | Valor |
| --- | --- |
| default | sqlserver://jdbc:sqlserver://sqlserver1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| sqlserver\$1catalog1\$1connection\$1string | sqlserver://jdbc:sqlserver://sqlserver1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| sqlserver\$1catalog2\$1connection\$1string | sqlserver://jdbc:sqlserver://sqlserver2.hostname:port;databaseName=;\$1\$1secret2\$1name\$1 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${secret_name}`.
```
sqlserver://jdbc:sqlserver://hostname:port;databaseName=;${secret_name}
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
sqlserver://jdbc:sqlserver://hostname:port;databaseName=;user=;password=
```
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do SQL Server.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | SqlServerCompositeHandler |
| Manipulador de metadados | SqlServerMetadataHandler |
| Manipulador de registros | SqlServerRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do SQL Server com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | sqlserver://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os tipos de dados correspondentes para SQL Server e Apache Arrow.
****
| SQL Server | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| date | Date(DAY) |
| horário | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
| nchar[n] | VARCHAR |
| nvarchar[n/max] | VARCHAR |
| texto | VARCHAR |
| ntext | VARCHAR |
## Partições e divisões
Uma partição é representada por uma única coluna de partição do tipo `varchar`. No caso do conector SQL Server, uma função de partição determina como as partições serão aplicadas na tabela. As informações sobre a função de partição e o nome da coluna são recuperadas da tabela de metadados do SQL Server. Em seguida, uma consulta personalizada obtém a partição. As divisões são criadas com base no número de partições distintas recebidas.
## desempenho
A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector SQL Server é resiliente ao controle de utilização devido à simultaneidade.
O concetor do Athena para o SQL Server realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. Predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL, que avalia para um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o SQL Server pode combinar essas expressões e passá-las diretamente ao SQL Server para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o SQL Server são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Consultas de passagem
O conector SQL Server é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o SQL Server, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no SQL Server. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/pom.xml) do conector SQL Server em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-sqlserver) em GitHub.com.
# Conector do Amazon Athena para o Teradata
O conector do Amazon Athena para o Teradata permite que o Amazon Athena execute consultas SQL em dados armazenados nos seus bancos de dados Teradata.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Limitações
+ Não há suporte para operações de gravação de DDL.
+ Em uma configuração de multiplexador, o prefixo e o bucket de derramamento são compartilhados em todas as instâncias do banco de dados.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
## Termos
Os termos a seguir estão relacionados ao conector Teradata.
+ **Instância do banco de dados**: qualquer instância de um banco de dados implantado on-premises, no Amazon EC2 ou no Amazon RDS.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
+ **Manipulador de multiplexação**: um manipulador Lambda que pode aceitar e usar várias conexões de banco de dados.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Teradata.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Teradata usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Teradata como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type TERADATA
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Teradata criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Teradata criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
teradata://${jdbc_connection_string}
```
#### Uso de um manipulador de multiplexação
É possível usar um multiplexador para se conectar a várias instâncias de banco de dados com uma única função do Lambda. As solicitações são encaminhadas por nome do catálogo. Use as seguintes classes no Lambda.
****
| Manipulador | Classe |
| --- | --- |
| Manipulador composto | TeradataMuxCompositeHandler |
| Manipulador de metadados | TeradataMuxMetadataHandler |
| Manipulador de registros | TeradataMuxRecordHandler |
##### Parâmetros do manipulador de multiplexação
****
| Parameter | Descrição |
| --- | --- |
| \$1catalog\$1connection\$1string | Obrigatório. Uma string de conexão de instância de banco de dados. Prefixe a variável de ambiente com o nome do catálogo usado no Athena. Por exemplo, se o catálogo registrado no Athena for myteradatacatalog, então o nome da variável de ambiente será myteradatacatalog\$1connection\$1string. |
| default | Obrigatório. A string de conexão padrão. Essa string é usada quando o catálogo for lambda:\$1\$1AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
As propriedades de exemplo a seguir são para uma função do Lambda MUX do Teradata que ofereça suporte a duas instâncias de banco de dados: `teradata1` (o padrão) e `teradata2`.
****
| Propriedade | Valor |
| --- | --- |
| default | teradata://jdbc:teradata://teradata2.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,user=sample2&password=sample2 |
| teradata\$1catalog1\$1connection\$1string | teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,\$1\$1Test/RDS/Teradata1\$1 |
| teradata\$1catalog2\$1connection\$1string | teradata://jdbc:teradata://teradata2.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,user=sample2&password=sample2 |
##### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nome secreto**
A string a seguir tem o nome secreto `${Test/RDS/Teradata1}`.
```
teradata://jdbc:teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,${Test/RDS/Teradata1}&...
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,...&user=sample2&password=sample2&...
```
Atualmente, o Teradata reconhece as propriedades `user` e `password` do JDBC. Ele também aceita o nome do usuário e a senha no formato *nome de usuário*`/`*senha* sem as chaves `user` ou `password`.
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância Teradata.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | TeradataCompositeHandler |
| Manipulador de metadados | TeradataMetadataHandler |
| Manipulador de registros | TeradataRecordHandler |
##### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
O exemplo de propriedade a seguir é para uma única instância do Teradata com suporte em uma função do Lambda.
****
| Propriedade | Valor |
| --- | --- |
| default | teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,secret=Test/RDS/Teradata1 |
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os correspondentes tipos de dados do JDBC e do Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Inteiro | Tiny |
| Short | Smallint |
| Inteiro | Int |
| Longo | Bigint |
| flutuação | Float4 |
| Duplo | Float8 |
| Data | Data/Dia |
| Timestamp | Date Milli |
| String | Varchar |
| Bytes | Varbinary |
| BigDecimal | Decimal |
| ARRAY | Lista |
## Partições e divisões
Uma partição é representada por uma única coluna de partição do tipo `Integer`. A coluna contém os nomes das partições definidas em uma tabela do Teradata. Para uma tabela que não tenha nomes de partição, \$1 será retornado, o que equivale a uma única partição. Uma partição é equivalente a uma divisão.
****
| Nome | Tipo | Descrição |
| --- | --- | --- |
| partição | Inteiro | Partição nomeada no Teradata. |
## desempenho
O Teradata oferece suporte a partições nativas. O conector do Athena para o Teradata pode recuperar dados dessas partições em paralelo. Se você quiser consultar conjuntos de dados muito grandes com distribuição uniforme de partições, o particionamento nativo é altamente recomendado. A seleção de um subconjunto de colunas diminui significativamente o runtime da consulta. O conector apresenta alguns controles de utilização devido à simultaneidade.
O conector do Athena para o Teradata realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. Predicados simples e expressões complexas são passados diretamente ao conector para reduzir a quantidade de dados examinados e o runtime de execução da consulta.
### Predicados
Um predicado é uma expressão na cláusula `WHERE` de uma consulta SQL que é avaliado como um valor booleano e filtra as linhas com base em várias condições. O conector do Athena para o Teradata pode combinar essas expressões e passá-las diretamente ao Synapse para melhorar a funcionalidade e reduzir a quantidade de dados examinados.
Os seguintes operadores do conector do Athena para o Teradata são compatíveis com a passagem direta de predicados:
+ **Booleanos:** E, OU, NÃO
+ **Igualdade:**EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritméticos:** ADICIONAR, SUBTRAIR, MULTIPLICAR, DIVIDIR, MÓDULO, NEGAR
+ **Outros:**LIKE\$1PATTERN, IN
### Exemplo de passagem direta combinada
Para ter recursos aprimorados de consulta, combine os tipos de passagem direta, como no seguinte exemplo:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Consultas de passagem
O conector Teradata é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Teradata, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Teradata. A consulta seleciona todas as colunas na tabela `customer`.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/pom.xml) do conector Teradata em GitHub.com.
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-teradata) em GitHub.com.
# Conector do Amazon Athena para o Timestream
O conector do Amazon Athena para o Timestream permite que o Amazon Athena se comunique com [Amazon Timestream](https://aws.amazon.com/timestream/), tornando seus dados de séries temporais acessíveis pelo Amazon Athena. Se preferir, use o AWS Glue Data Catalog como uma fonte de metadados complementares.
O Amazon Timestream é um banco de dados de séries temporais rápido, escalável, totalmente gerenciado e criado para fins específicos que facilita o armazenamento e a análise de trilhões de pontos de dados de séries temporais por dia. O Timestream economiza tempo e custo de gerenciamento do ciclo de vida dos dados de séries temporais mantendo os dados recentes na memória e movendo os dados históricos para um nível de armazenamento com otimização de custo conforme as políticas definidas pelo usuário.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
Se você tiver o Lake Formation habilitado em sua conta, o perfil do IAM para seu conector Lambda federado para Athena que você implantou no AWS Serverless Application Repository deve ter acesso de leitura ao AWS Glue Data Catalog no Lake Formation.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector Timestream.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Timestream usando um objeto de conexão do Glue. Para fazer isso, defina a variável de ambiente `glue_connection` da função do Lambda para o conector do Timestream com o nome da conexão do Glue que deseja usar.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type TIMESTREAM
```
**Propriedades do ambiente do Lambda**
**glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Timestream criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Timestream criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes dos parâmetros e suas definições listados abaixo referem-se a conectores de fonte de dados do Athena criados sem uma conexão do Glue associada. Os parâmetros apresentados abaixo devem ser usados somente quando você [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena ou quando a propriedade de ambiente `glue_connection` não for especificada.
**Propriedades do ambiente do Lambda**
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar a performance, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **glue\$1catalog**: (opcional) use essa opção para especificar um [catálogo do AWS Glue entre contas](data-sources-glue-cross-account.md). Por padrão, o conector tenta obter metadados de sua própria conta do AWS Glue.
## Configuração de bancos de dados e tabelas no AWS Glue
Se preferir, use o AWS Glue Data Catalog como uma fonte de metadados complementares. Para habilitar uma tabela do AWS Glue para uso com o Timestream, é preciso ter um banco de dados do AWS Glue e uma tabela com nomes que correspondam ao banco de dados Timestream e à tabela para a qual você deseja fornecer metadados complementares.
**nota**
Para obter a melhor performance, use somente letras minúsculas para nomes de banco de dados e nomes de tabela. O uso de maiúsculas e minúsculas mistas faz com que o conector execute uma pesquisa que não diferencia maiúsculas de minúsculas e é mais computacionalmente intensiva.
Para configurar a tabela do AWS Glue para uso com o Timestream é preciso definir suas propriedades de tabela em AWS Glue.
**Para usar uma tabela do AWS Glue para metadados complementares**
1. Edite a tabela no console do AWS Glue para adicionar as seguintes propriedades da tabela:
+ **timestream-metadata-flag**: essa propriedade indica ao conector Timestream que o conector pode usar a tabela para metadados complementares. É possível fornecer qualquer valor para `timestream-metadata-flag`, desde que a propriedade `timestream-metadata-flag` esteja presente na lista de propriedades da tabela.
+ **\$1view\$1template**: quando você usa o AWS Glue para metadados complementares, é possível usar essa propriedade da tabela e especificar qualquer Timestream SQL como visualização. O conector Timestream do Athena usa o SQL da visualização junto com o SQL do Athena para executar sua consulta. Isso é útil se você quiser usar um recurso do Timestream SQL que, de outra forma, não está disponível no Athena.
1. Use os tipos de dados apropriados para o AWS Glue, conforme listado neste documento.
### Tipos de dados
Atualmente, o conector Timestream oferece suporte somente a um subconjunto dos tipos de dados disponíveis no Timestream, especificamente: os valores escalares `varchar`, `double` e `timestamp`.
Para consultar o tipo de dados da `timeseries`, é preciso configurar uma visualização nas propriedades da tabela do AWS Glue que use a função `CREATE_TIME_SERIES` do Timestream. Você também precisa fornecer um esquema para a visualização que use a sintaxe `ARRAY>` como o tipo de qualquer uma de suas colunas de séries temporais. Certifique-se de substituir `double` pelo tipo escalar apropriado para sua tabela.
A imagem a seguir mostra um exemplo de propriedades da tabela do AWS Glue configuradas para definir uma visualização sobre uma série temporal.
![\[Configuração de propriedades de tabelas no AWS Glue para definir uma visualização de uma série temporal.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-timestream-1.png)
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-timestream.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-timestream/athena-timestream.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
+ **AWS Glue Data Catalog**: o conector Timestream requer acesso somente de leitura ao AWS Glue Data Catalog para obter informações do esquema.
+ **CloudWatch Logs**: o conector requer acesso ao CloudWatch Logs para armazenar registros.
+ **Acesso ao Timestream**: para executar consultas no Timestream.
## desempenho
Recomendamos o uso da cláusula `LIMIT` para limitar os dados retornados (não os dados verificados) a menos de 256 MB com a finalidade de garantir que as consultas interativas tenham uma boa performance.
O conector do Athena para o Timestream realiza a passagem direta de predicados para diminuir os dados examinados pela consulta. As cláusulas `LIMIT` reduzem a quantidade de dados examinados, mas, se você não fornecer um predicado, deverá esperar que as consultas `SELECT` com uma cláusula `LIMIT` examinem, pelo menos, 16 MB de dados. A seleção de um subconjunto de colunas acelera o runtime da consulta e reduz os dados verificados de forma significativa. O conector Timestream é resiliente ao controle de utilização devido à simultaneidade.
## Consultas de passagem
O conector Timestream é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Timestream, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Timestream. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
O projeto do conector Timestream do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-timestream) em GitHub.com.
# Conector do Amazon Athena para o TPC Benchmark DS (TPC-DS)
O conector TPC-DS no Amazon Athena permite que o Amazon Athena se comunique com uma fonte de dados do TPC Benchmark DS gerada aleatoriamente para uso em benchmarking e testes funcionais do Athena Federation. O conector TPC-DS no Athena gera um banco de dados compatível com TPC-DS em um dos quatro fatores de escala. Não recomendamos o uso desse conector como alternativa aos testes de desempenho de data lake baseados no Amazon S3.
Esse conector pode ser registrado como um catálogo federado no Glue Data Catalog. Ele é compatível com controles de acesso a dados definidos no Lake Formation nos níveis de catálogo, banco de dados, tabela, coluna, linha e tag. Esse conector usa o Glue Connections para centralizar as propriedades de configuração no Glue.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do TPC-DS.
**nota**
Os conectores de fonte de dados do Athena criados a partir de 3 de dezembro de 2024 usam conexões do AWS Glue.
Os nomes e definições dos parâmetros listados abaixo são para conectores de fonte de dados do Athena criados antes de 3 de dezembro de 2024. Eles podem diferir de suas [propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) correspondentes. A partir de 3 de dezembro de 2024, use os parâmetros abaixo somente ao [implantar manualmente](connect-data-source-serverless-app-repo.md) uma versão anterior de um conector de fonte de dados do Athena.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do TPC-DS usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do TPC-DS como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type TPCDS
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do TPC-DS criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do TPC-DS criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
+ **spill\$1bucket**: especifica o bucket do Amazon S3 para dados que excedem os limites da função do Lambda.
+ **spill\$1prefix**: (opcional) assume como padrão uma subpasta no `spill_bucket` especificado chamado `athena-federation-spill`. Recomendamos que você configure um [ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3 neste local para excluir derramamentos anteriores a um número predeterminado de dias ou horas.
+ **spill\$1put\$1request\$1headers**: (opcional) um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação `putObject` do Amazon S3 usada para o derramamento (por exemplo, `{"x-amz-server-side-encryption" : "AES256"}`). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na *Referência da API do Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (opcional) por padrão, todos os dados transmitidos para o Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente. Para que sua função do Lambda use chaves de criptografia mais fortes geradas pelo KMS, como `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, é possível especificar um ID de chave do KMS.
+ **disable\$1spill\$1encryption**: (opcional) quando definido como `True`, desativa a criptografia do derramamento. É padronizado como `False`, para que os dados transmitidos para o S3 sejam criptografados usando o AES-GCM — usando uma chave gerada aleatoriamente ou o KMS para gerar chaves. Desativar a criptografia do derramamento pode melhorar o desempenho, especialmente se o local do derramamento usar [criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
## Teste de bancos de dados e tabelas
O conector TPC-DS no Athena gera um banco de dados compatível com TPC-DS em um dos quatro fatores de escala `tpcds1`, `tpcds10`, `tpcds100`, `tpcds250` ou `tpcds1000`.
### Resumo de tabelas
Para obter uma lista completa de tabelas e colunas de dados de teste, execute a consulta `SHOW TABLES` ou `DESCRIBE TABLE`. O resumo de tabelas a seguir é fornecido para sua conveniência.
1. call\$1center
1. catalog\$1page
1. catalog\$1returns
1. catalog\$1sales
1. customer
1. customer\$1address
1. customer\$1demographics
1. date\$1dim
1. dbgen\$1version
1. household\$1demographics
1. income\$1band
1. Inventory
1. item
1. promotion
1. reason
1. ship\$1mode
1. armazenamento
1. store\$1returns
1. store\$1sales
1. time\$1dim
1. warehouse
1. web\$1page
1. web\$1returns
1. web\$1sales
1. web\$1site
Para consultas do TPC-DS que sejam compatíveis com esse esquema e dados gerados, consulte o diretório [athena-tpcds/src/main/resources/query](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds/src/main/resources/queries) no GitHub.
### Consulta de exemplo
O exemplo de consulta `SELECT` a seguir consulta o catálogo `tpcds` para dados demográficos de clientes em países específicos.
```
SELECT
cd_gender,
cd_marital_status,
cd_education_status,
count(*) cnt1,
cd_purchase_estimate,
count(*) cnt2,
cd_credit_rating,
count(*) cnt3,
cd_dep_count,
count(*) cnt4,
cd_dep_employed_count,
count(*) cnt5,
cd_dep_college_count,
count(*) cnt6
FROM
"lambda:tpcds".tpcds1.customer c, "lambda:tpcds".tpcds1.customer_address ca, "lambda:tpcds".tpcds1.customer_demographics
WHERE
c.c_current_addr_sk = ca.ca_address_sk AND
ca_county IN ('Rush County', 'Toole County', 'Jefferson County',
'Dona Ana County', 'La Porte County') AND
cd_demo_sk = c.c_current_cdemo_sk AND
exists(SELECT *
FROM "lambda:tpcds".tpcds1.store_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = ss_customer_sk AND
ss_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3) AND
(exists(SELECT *
FROM "lambda:tpcds".tpcds1.web_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = ws_bill_customer_sk AND
ws_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3) OR
exists(SELECT *
FROM "lambda:tpcds".tpcds1.catalog_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = cs_ship_customer_sk AND
cs_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3))
GROUP BY cd_gender,
cd_marital_status,
cd_education_status,
cd_purchase_estimate,
cd_credit_rating,
cd_dep_count,
cd_dep_employed_count,
cd_dep_college_count
ORDER BY cd_gender,
cd_marital_status,
cd_education_status,
cd_purchase_estimate,
cd_credit_rating,
cd_dep_count,
cd_dep_employed_count,
cd_dep_college_count
LIMIT 100
```
## Permissões obrigatórias
Os detalhes completos sobre as políticas do IAM exigidas por esse conector podem ser encontrados na seção `Policies` do arquivo [athena-tpcds.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-tpcds/athena-tpcds.yaml). A lista a seguir resume as permissões necessárias.
+ **Acesso de gravação do Amazon S3**: o conector requer acesso de gravação a um local no Amazon S3 para mostrar resultados de grandes consultas.
+ **Athena GetQueryExecution**: o conector usa esta permissão para falhar rapidamente quando a consulta upstream do Athena é encerrada.
## desempenho
O conector TPC-DS do Athena tenta paralelizar as consultas com base no fator de escala que você escolher. A redução de predicados é realizada dentro da função do Lambda.
## Informações de licença
O projeto do conector TPC-DS do Amazon Athena é licenciado sob a [Licença Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Recursos adicionais
Para obter mais informações sobre esse conector, visite [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds) em GitHub.com.
# Conector do Amazon Athena para o Vertica
O Vertica é uma plataforma de banco de dados em colunas que pode ser implantada na nuvem ou on-premises e que oferece suporte a data warehouses em escala de exabytes. Você pode usar o conector do Vertica para Amazon Athena em consultas federadas para consultar origens de dados do Vertica usando o Athena. Por exemplo, você pode executar consultas analíticas em um data warehouse no Vertica e um data lake no Amazon S3.
Esse conector não usa o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
## Pré-requisitos
+ Implante o conector na sua Conta da AWS usando o console do Athena ou o AWS Serverless Application Repository. Para ter mais informações, consulte [Criar uma conexão de fonte de dados](connect-to-a-data-source.md) ou [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md).
+ Configura uma VPC e um grupo de segurança antes de usar esse conector. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
## Limitações
+ Como o conector Vertica do Athena lê arquivos exportados Parquet do Amazon S3, o desempenho do conector pode ser lento. Ao consultar tabelas grandes, recomendamos usar uma consulta [CREATE TABLE AS (SELECT ...)](ctas.md) e predicados de SQL.
+ Atualmente, devido a um problema conhecido na consulta federada do Athena, o conector faz com que o Vertica exporte todas as colunas da tabela consultada para o Amazon S3, mas somente as colunas consultadas estão visíveis nos resultados no console do Athena.
+ Não há suporte para operações de gravação de DDL.
+ Quaisquer limites relevantes do Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
## Fluxo de trabalho
O diagrama a seguir mostra o fluxo de trabalho de uma consulta que use o conector Vertica.
![\[Fluxo de trabalho de uma consulta Vertica do Amazon Athena\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-vertica-1.png)
1. Uma consulta SQL é emitida em uma ou mais tabelas no Vertica.
1. O conector analisa a consulta SQL para enviar a parte relevante para o Vertica por meio da conexão do JDBC.
1. As strings de conexão usam o nome de usuário e a senha armazenados no AWS Secrets Manager para obter acesso ao Vertica.
1. O conector envolve a consulta SQL com um comando `EXPORT` do Vertica, como no exemplo a seguir.
```
EXPORT TO PARQUET (directory = 's3://amzn-s3-demo-bucket/folder_name,
Compression='Snappy', fileSizeMB=64) OVER() as
SELECT
PATH_ID,
...
SOURCE_ITEMIZED,
SOURCE_OVERRIDE
FROM DELETED_OBJECT_SCHEMA.FORM_USAGE_DATA
WHERE PATH_ID <= 5;
```
1. O Vertica processa a consulta SQL e envia o conjunto de resultados para um bucket do Amazon S3. Para uma melhor throughput, o Vertica usa a opção `EXPORT` para paralelizar a operação de gravação de vários arquivos Parquet.
1. O Athena examina o bucket do Amazon S3 para determinar o número de arquivos a serem lidos para o conjunto de resultados.
1. O Athena faz várias chamadas para a função do Lambda e usa o Apache `ArrowReader` para ler os arquivos Parquet do conjunto de resultados. Várias chamadas permitem que o Athena paralelize a leitura dos arquivos do Amazon S3 e alcance uma throughput de até 100 GB por segundo.
1. O Athena processa os dados retornados do Vertica com dados examinados do data lake e retorna o resultado.
## Termos
Os termos a seguir estão relacionados ao conector Vertica.
+ **Instância do banco de dados**: qualquer instância de um banco de dados Vertica implantado no Amazon EC2.
+ **Manipulador**: um manipulador Lambda que acessa sua instância de banco de dados. Um manipulador pode ser para metadados ou para registros de dados.
+ **Manipulador de metadados**: um manipulador Lambda que recupera metadados da sua instância de banco de dados.
+ **Manipulador de registros**: um manipulador Lambda que recupera registros de dados da sua instância de banco de dados.
+ **Manipulador composto**: um manipulador Lambda que recupera tanto metadados quanto registros de dados da sua instância de banco de dados.
+ **Propriedade ou parâmetro**: uma propriedade do banco de dados usada pelos manipuladores para extrair informações do banco de dados. Você configura essas propriedades como variáveis de ambiente do Lambda.
+ **String de conexão**: uma string de texto usada para estabelecer uma conexão com uma instância de banco de dados.
+ **Catálogo**: um catálogo não AWS Glue registrado no Athena que é um prefixo obrigatório para a propriedade `connection_string`.
## Parâmetros
Use os parâmetros nesta seção para configurar o conector do Vertica.
### Conexões do Glue (recomendação)
Recomendamos que você configure um conector do Vertica usando um objeto de conexão do Glue. Para isso, defina a variável de ambiente `glue_connection` do Lambda do conector do Vertica como o nome da conexão do Glue a ser usada.
**Propriedades das conexões do Glue**
Use o comando apresentado a seguir para obter o esquema de um objeto de conexão do Glue. Esse esquema contém todos os parâmetros que você pode usar para controlar a conexão.
```
aws glue describe-connection-type --connection-type VERTICA
```
**Propriedades do ambiente do Lambda**
+ **glue\$1connection**: especifica o nome da conexão do Glue associada ao conector federado.
+ **casing\$1mode** (Opcional): especifica como lidar com maiúsculas e minúsculas para nomes de esquemas e tabelas. O parâmetro `casing_mode` usa os seguintes valores para especificar o comportamento do mapeamento de maiúsculas e minúsculas:
+ **none**: não altera as maiúsculas e minúsculas dos nomes de esquema e tabela fornecidos. Esse é o padrão para conectores que têm uma conexão do Glue associada.
+ **upper**: converte para maiúsculas todos os nomes de esquema e tabela fornecidos.
+ **lower**: converte para minúsculas todos os nomes de esquema e tabela fornecidos.
**nota**
Todos os conectores que usam conexões do Glue devem usar o AWS Secrets Manager para armazenar credenciais.
O conector do Vertica criado usando conexões do Glue não é compatível com o uso de um manipulador de multiplexação.
O conector do Vertica criado usando conexões do Glue é compatível apenas com o `ConnectionSchemaVersion` 2.
### Conexões legadas
O conector do Amazon Athena para o Vertica expõe as opções de configuração por meio das variáveis de ambiente do Lambda. É possível usar as seguintes variáveis de ambiente do Lambda para definir o conector.
+ **AthenaCatalogName**: nome da função do Lambda
+ **ExportBucket**: o bucket do Amazon S3 para onde os resultados de consultas do Vertica são exportados.
+ **SpillBucket**: o nome do bucket do Amazon S3 no qual essa função pode derramar dados.
+ **SpillPrefix**: o prefixo para a localização do `SpillBucket` onde essa função pode derramar dados.
+ **SecurityGroupIds**: um ou mais IDs que correspondem ao grupo de segurança que deve ser aplicado à função do Lambda (por exemplo, `sg1`, `sg2` ou `sg3`).
+ **SubnetIds**: uma ou mais IDs de sub-rede que correspondem à sub-rede que a função do Lambda pode usar para acessar sua fonte de dados (por exemplo, `subnet1` ou `subnet2`).
+ **SecretNameOrPrefix**: o nome ou prefixo de um conjunto de nomes no Secrets Manager ao qual essa função tem acesso (por exemplo, `vertica-*`)
+ **VerticaConnectionString**: os detalhes da conexão do Vertica a serem usados por padrão se nenhuma conexão específica do catálogo for definida. A string pode opcionalmente usar a sintaxe do AWS Secrets Manager (por exemplo, `${secret_name}`).
+ **VPC ID**: o ID da VPC a ser associada à função do Lambda.
#### String de conexão
Use uma string de conexão JDBC no seguinte formato para se conectar a uma instância de banco de dados.
```
vertica://jdbc:vertica://host_name:
port/database?user=vertica-username&password=
vertica-password
```
#### Uso de um único manipulador de conexão
É possível usar os seguintes metadados de conexão única e manipuladores de registros para se conectar a uma única instância do Vertica.
****
| Tipo de manipulador | Classe |
| --- | --- |
| Manipulador composto | VerticaCompositeHandler |
| Manipulador de metadados | VerticaMetadataHandler |
| Manipulador de registros | VerticaRecordHandler |
#### Parâmetros do manipulador de conexão única
****
| Parameter | Descrição |
| --- | --- |
| default | Obrigatório. A string de conexão padrão. |
Os manipuladores de conexão únicos oferecem suporte a uma instância de banco de dados e devem fornecer um parâmetro de string de conexão `default`. Todas as outras strings de conexão são ignoradas.
#### Fornecimento de credenciais
Para fornecer um nome de usuário e uma senha para seu banco de dados na string de conexão JDBC, é possível usar as propriedades da string de conexão ou o AWS Secrets Manager.
+ **String de conexão**: um nome de usuário e uma senha podem ser especificados como propriedades na string de conexão do JDBC.
**Importante**
Como prática recomendada de segurança, não use credenciais com codificação rígida em suas variáveis de ambiente ou strings de conexão. Para obter informações sobre como mover seus segredos codificados para o AWS Secrets Manager, consulte [Mover segredos codificados para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) no *Guia do usuário do AWS Secrets Manager*.
+ **AWS Secrets Manager**: para usar o recurso Athena Federated Query com o AWS Secrets Manager, a VPC conectada à sua função do Lambda deve ter [acesso à Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) ou um [endpoint da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) para se conectar ao Secrets Manager.
É possível colocar o nome de um segredo no AWS Secrets Manager na sua string de conexão JDBC. O conector substitui o nome secreto pelos valores de `username` e `password` do Secrets Manager.
Para instâncias de banco de dados do Amazon RDS, esse suporte é totalmente integrado. Se você usa o Amazon RDS, é altamente recomendável usar o AWS Secrets Manager e rotação de credenciais. Se seu banco de dados não usar o Amazon RDS, armazene as credenciais em JSON no seguinte formato:
```
{"username": "${username}", "password": "${password}"}
```
**Exemplo de string de conexão com nomes secretos**
A string a seguir tem os nomes secretos \$1\$1`vertica-username`\$1 e `${vertica-password}`.
```
vertica://jdbc:vertica://
host_name:port/database?user=${vertica-username}&password=${vertica-password}
```
O conector usa o nome secreto para recuperar segredos e fornecer o nome de usuário e a senha, como no exemplo a seguir.
```
vertica://jdbc:vertica://
host_name:port/database?user=sample-user&password=sample-password
```
Atualmente, o conector Vertica reconhece as propriedades `vertica-username` e `vertica-password` do JDBC.
#### Parâmetros de derramamento
O SDK do Lambda pode derramar dados no Amazon S3. Todas as instâncias do banco de dados acessadas pela mesma função do Lambda derramam no mesmo local.
****
| Parameter | Descrição |
| --- | --- |
| spill\$1bucket | Obrigatório. Nome do bucket de derramamento. |
| spill\$1prefix | Obrigatório. Prefixo de chave do bucket de derramamento. |
| spill\$1put\$1request\$1headers | (Opcional) Um mapa codificado em JSON de cabeçalhos e valores de solicitações para a solicitação putObject do Amazon S3 usada para o derramamento (por exemplo, \$1"x-amz-server-side-encryption" : "AES256"\$1). Para outros cabeçalhos possíveis, consulte [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) na Referência da API do Amazon Simple Storage Service. |
## Suporte ao tipo de dados
A tabela a seguir mostra os tipos de dados com suporte pelo conector Vertica.
****
| Booleano |
| --- |
| BigInt |
| Short |
| Inteiro |
| Longo |
| Float |
| Duplo |
| Data |
| Varchar |
| Bytes |
| BigDecimal |
| TimeStamp como Varchar |
## desempenho
A função do Lambda realiza o empilhamento de projeções para diminuir os dados verificados pela consulta. As cláusulas `LIMIT` reduzem a quantidade de dados verificados, mas se você não fornecer um predicado, deverá aguardar que as consultas `SELECT` com uma cláusula `LIMIT` verifiquem, no mínimo, 16 MB de dados. O conector Vertica é resiliente ao controle de utilização devido à simultaneidade.
## Consultas de passagem
O conector Vertica é compatível com [consultas de passagem](federated-query-passthrough.md). As consultas de passagem usam uma função de tabela para enviar sua consulta completa para execução na fonte de dados.
Para usar consultas de passagem com o Vertica, você pode empregar a seguinte sintaxe:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados no Vertica. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informações de licença
Ao usar esse conector, você reconhece a inclusão de componentes de terceiros, cuja lista pode ser encontrada no arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/pom.xml) desse conector, e concorda com os termos das respectivas licenças de terceiros fornecidas no arquivo [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/LICENSE.txt) em GitHub.com.
## Recursos adicionais
Para obter as informações mais recentes sobre a versão do driver JDBC, consulte o arquivo [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/pom.xml) do conector Vertica em GitHub.com.
Para obter mais informações sobre esse conector, consulte [o site correspondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-vertica) em GitHub.com e [Consulta de uma fonte de dados do Vertica no Amazon Athena usando o SDK Athena Federated Query](https://aws.amazon.com/blogs/big-data/querying-a-vertica-data-source-in-amazon-athena-using-the-athena-federated-query-sdk/) no *Blog de big data da AWS*.
# Criar uma conexão de fonte de dados
Para usar um conector de fonte de dados do Athena, você cria a conexão AWS Glue que armazena as informações de conexão sobre o conector e sua fonte de dados. Ao criar a conexão, você informa à fonte de dados um nome que usará para fazer referência à sua fonte de dados em suas consultas SQL.
É possível criar e configurar uma conexão de fonte de dados no Athena usando o [console](connect-to-a-data-source-console-steps.md) ou as operações da API [CreateDataCatalog](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateDataCatalog.html).
**Topics**
+ [Permissões para criar e usar uma fonte de dados no Athena](connect-to-a-data-source-permissions.md)
+ [Usar o console do Athena para conectar a uma fonte de dados](connect-to-a-data-source-console-steps.md)
+ [Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados](connect-data-source-serverless-app-repo.md)
+ [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md)
+ [Extrair imagens do ECR para sua conta da AWS](pull-ecr-customer-account.md)
+ [Registrar sua conexão como um Glue Data Catalog](register-connection-as-gdc.md)
+ [Habilitar consultas federadas entre contas](xacct-fed-query-enable.md)
+ [Atualizar um conector de fonte de dados](connectors-updating.md)
# Permissões para criar e usar uma fonte de dados no Athena
Para criar e usar uma fonte de dados, você precisa dos seguintes conjuntos de permissões.
+ AmazonAthenaFullAccess, que fornece acesso total ao Amazon Athena e acesso limitado às dependências necessárias para permitir a consulta, a gravação de resultados e o gerenciamento de dados. Para obter mais informações, consulte [AmazonAthenaFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html) no Guia de referência de política gerenciada da AWS.
+ Permissões para chamar a API CreateDataCatalog. Essas permissões só são necessárias quando você cria uma fonte de dados que se integra às conexões do Glue. Para obter mais informações sobre o exemplo de política, consulte [Permissões necessárias para criar o conector e o catálogo do Athena](athena-catalog-access.md).
+ Se quiser usar o controle de acesso refinado do Lake Formation, além das permissões listadas acima, você também precisará das seguintes permissões.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:RegisterResource",
"iam:ListRoles",
"glue:CreateCatalog",
"glue:GetCatalogs",
"glue:GetCatalog"
],
"Resource": "*"
}
]
}
```
------
# Usar o console do Athena para conectar a uma fonte de dados
Você pode usar o console do Athena para criar e configurar uma conexão de fonte de dados.
**Criar uma conexão com uma fonte de dados**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Em **Choose a data source** (Escolher uma origem dos dados), escolha a origem dos dados que o Athena deve consultar, considerando as seguintes diretrizes:
+ Escolha uma opção de conexão que corresponda à sua fonte de dados. O Athena tem conectores de origem dos dados pré-criados que você pode configurar para origens que incluem o MySQL, o Amazon DocumentDB e o PostgreSQL.
+ Escolha **S3 - AWS Glue Data Catalog** se quiser consultar dados no Amazon S3 e não estiver usando um metastore do Apache Hive ou uma das outras opções de origem dos dados de consulta federada nesta página. O Athena usa o AWS Glue Data Catalog para armazenar metadados e informações de esquemas para origens dos dados no Amazon S3. Essa é a opção padrão (não federada). Para obter mais informações, consulte [Usar o AWS Glue Data Catalog para se conectar aos seus dados](data-sources-glue.md). Para ver as etapas de uso desse fluxo de trabalho, consulte [Registrar e usar catálogos de dados no Athena](gdc-register.md).
+ Selecione **S3 - Apache Hive metastore** para consultar conjuntos de dados no Amazon S3 que usam um metastore do Apache Hive. Para obter mais informações sobre essa opção, consulte [Conectar o Athena a um metastore do Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md).
+ Escolha **Custom or shared connector** (Conector personalizado ou compartilhado) se quiser criar seu próprio conector de origem dos dados para usar com o Athena. Para obter informações sobre como escrever um conector de origem dos dados, consulte [Desenvolver um conector de fonte de dados com uso do SDK do Athena Query Federation](connect-data-source-federation-sdk.md).
1. Escolha **Próximo**.
1. Na página **Inserir detalhes da fonte de dados**, em **Nome da fonte de dados**, insira o nome gerado automaticamente ou um nome exclusivo que deseja usar em suas instruções SQL ao consultar a fonte de dados usando o Athena. O nome pode ter até 127 caracteres e deve ser exclusivo na sua conta. Ele não poderá ser alterado após a criação. Os caracteres válidos são a-z, A-Z, 0-9, \$1 (sublinhado), @ (arroba) e - (hífen). Os nomes `awsdatacatalog`, `hive`, `jmx` e `system` são reservados pelo Athena e não podem ser usados como nomes de origens dos dados.
1. Se a fonte de dados escolhida tiver integração com conexões do AWS Glue.
1. Em **obter detalhes da conexão do AWS Glue**, insira as informações necessárias. Uma conexão que contém as propriedades necessárias para se conectar a uma fonte de dados específica. As propriedades necessárias variam de acordo com o tipo de conexão. Para obter mais informações sobre propriedades relacionadas ao seu conector, consulte [Conectores de fonte de dados disponíveis](connectors-available.md). Para obter informações sobre propriedades adicionais de conexão, consulte [Propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) no *Guia do usuário do AWS Glue*.
**nota**
Quando você atualiza as propriedades de conexão do Glue, o conector Lambda precisa ser reiniciado para obter as propriedades atualizadas. Para fazer isso, edite as propriedades do ambiente e salve-as sem alterar efetivamente nada.
Quando você atualizar uma conexão do Glue, as propriedades a seguir não serão atualizadas automaticamente na função do Lambda correspondente. Você deverá atualizar manualmente sua função do Lambda para essas propriedades.
Configuração de VPC do Lambda: `security_group_ids`, `subnet_ids`
Perfil de execução do Lambda: `spill_bucket`, `secret_name`, `spill_kms_key_id`
1. Em **Perfil do IAM de execução do Lambda**, escolha uma das seguintes opções:
+ **Criar e usar um novo perfil de execução**: (Padrão) o Athena cria um perfil de execução que será usado para acessar recursos no AWS Lambda em seu nome. O Athena exige esse perfil para criar sua fonte de dados federada.
+ **Usar um perfil de execução existente**: use essa opção para escolher um perfil de execução existente. Para essa opção, escolha o perfil de execução que deseja usar no menu suspenso **Perfil de execução**.
1. Se a fonte de dados escolhida não tiver integração com conexões do AWS Glue.
1. Em **Lambda function** (Função do Lambda), escolha **Create Lambda function** (Criar função do Lambda). A página de função do conector escolhido será aberta no console do AWS Lambda. A página inclui informações detalhadas sobre o conector.
1. Em **Application settings** (Configurações da aplicação), leia atentamente a descrição de cada configuração de aplicação e insira os valores de acordo com os seus requisitos.
As configurações de aplicação exibidas variam dependendo do conector da sua origem dos dados. As configurações mínimas necessárias são:
+ **AthenaCatalogName**: um nome para a função do Lambda, em letras minúsculas, que indica a origem dos dados desejada, como `cloudwatchlogs`.
+ **SpillBucket**: um bucket do Amazon S3 em sua conta para armazenar os dados que excedem os limites de tamanho de resposta da função do Lambda.
**nota**
Dados derramados não serão reutilizados em execuções subsequentes e poderão ser excluídos com segurança. O Athena não os exclui para você. Para gerenciar esses objetos, considere adicionar uma política de ciclo de vida de objetos que exclua dados antigos do seu bucket de derramamento do Amazon S3. Para obter mais informações, consulte [Gerenciar o ciclo de vida dos objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) no Guia do usuário do Amazon S3.
1. Selecione **Reconheço que este aplicativo cria perfis personalizadas do IAM e políticas de recursos**. Para obter mais informações, escolha o link **Informações**.
1. Escolha **Implantar**. Quando a implantação for concluída, a função do Lambda será exibida seção **Resources** (Recursos) no console do Lambda.
Depois de implantar o conector da origem dos dados em sua conta, você poderá conectar o Athena a ele.
1. Retorne à página **Enter data source details** (Inserir detalhes da origem dos dados) do console do Athena.
1. Na seção **Connection details** (Detalhes da conexão), escolha o ícone de atualização ao lado da caixa de pesquisa **Select or enter a Lambda function** (Selecionar ou inserir uma função do Lambda).
1. Escolha o nome da função que você acabou de criar no console do Lambda. O ARN da função do Lambda é exibido.
1. (Opcional) Para **Tags**, adicione pares de chave-valor a associar com essa origem dos dados. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Próximo**.
1. Na página **Revisar e criar**, revise os detalhes da fonte de dados. Para fazer alterações, escolha **Editar**.
1. Leia as informações em **O Athena criará recursos em sua conta**. Se você concordar, selecione **Reconheço que o Athena criará recursos em meu nome**.
1. Escolha **Criar fonte de dados**. O **Athena** criará os seguintes recursos para você.
+ Perfil do IAM de execução do Lambda
+ Conexão do AWS Glue (somente se a fonte de dados for compatível com conexões do AWS Glue)
+ Função do Lambda
A seção **Data source details** (Detalhes da origem dos dados) da página de sua origem dos dados mostra informações sobre o novo conector. Agora é possível usar o conector em suas consultas do Athena.
Para obter informações sobre como usar conectores de dados em consultas, acesse [Executar consultas federadas](running-federated-queries.md).
# Usar o AWS Serverless Application Repository para implantar um conector de fonte de dados
Para implantar um conector de fonte de dados, você pode usar o [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) em vez de usar uma conexão do AWS Glue.
**nota**
Recomendamos que você só use o SAR se tiver um conector personalizado ou precisar usar um conector mais antigo. Caso contrário, recomenda-se usar o console do Athena.
É possível recorrer ao AWS Serverless Application Repository para encontrar o conector que deseja usar, fornecer os parâmetros que o conector exige e implantar o conector em sua conta. Depois de implantar o conector, você usa o console do Athena para disponibilizar a origem dos dados para o Athena.
## Implantar o conector em sua conta
**Como usar o AWS Serverless Application Repository para implantar um conector de fonte de dados em sua conta**
1. Faça login no Console de gerenciamento da AWS e abra o **Repositório de aplicativos sem servidor**.
1. No painel de navegação, escolha **Aplicativos disponíveis**.
1. Selecione a opção **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções personalizadas do IAM ou políticas de recursos).
1. Na caixa de pesquisa, digite o nome do conector. Para obter uma lista de conectores de dados predefinidos do Athena, consulte [Conectores de fonte de dados disponíveis](connectors-available.md).
1. Escolha o nome do conector. Ao escolher um conector, a página **Application details** (Detalhes da aplicação) da função do Lambda no console do AWS Lambda é aberta.
1. No lado direito da página de detalhes, em **Application settings** (Configurações da aplicação), preencha as informações necessárias. As configurações mínimas necessárias são mostradas a seguir. Para obter informações sobre as opções configuráveis restantes de conectores de dados criados pelo Athena, consulte o tópico [Available Connectors](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors) (Conectores disponíveis) no GitHub.
+ **AthenaCatalogName**: um nome para a função do Lambda em letras minúsculas que indica a origem dos dados desejada, como `cloudwatchlogs`.
+ **SpillBucket**: especifique um bucket do Amazon S3 em sua conta para receber os dados de qualquer carga útil de resposta grande que exceda os limites de tamanho de resposta da função do Lambda.
1. Selecione **I acknowledge that this app creates custom IAM roles and resource policies** (Reconheço que este aplicativo cria funções personalizadas do IAM e políticas de recursos). Para obter mais informações, escolha o link **Informações**.
1. Na parte inferior direita da página **Configurações da aplicação** selecione **Implantar**. Quando a implantação for concluída, a função do Lambda será exibida seção **Resources** (Recursos) no console do Lambda.
## Disponibilizar o conector no Athena
Agora você já pode usar o console do Athena para disponibilizar o conector da origem dos dados para o Athena.
**Para disponibilizar o conector da origem dos dados para o Athena**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Em **Choose a data source** (Escolher uma origem dos dados), escolha a origem dos dados para a qual você criou um conector no AWS Serverless Application Repository. Este tutorial usa o **Amazon CloudWatch Logs** como origem dos dados federada.
1. Escolha **Próximo**.
1. Na página **Enter data source details** (Inserir detalhes da origem dos dados), em **Data source name** (Nome da origem dos dados), insira o nome que deseja usar em suas instruções SQL ao consultar a origem dos dados pelo Athena (por exemplo, `CloudWatchLogs`). O nome pode ter até 127 caracteres e deve ser exclusivo na sua conta. Ele não poderá ser alterado após a criação. Os caracteres válidos são a-z, A-Z, 0-9, \$1 (sublinhado), @ (arroba) e - (hífen). Os nomes `awsdatacatalog`, `hive`, `jmx` e `system` são reservados pelo Athena e não podem ser usados como nomes de origens dos dados.
1. Na seção **Connection details** (Detalhes da conexão), use a caixa **Select or enter a Lambda function** (Selecionar ou inserir uma função do Lambda) para escolher o nome da função que você acabou de criar. O ARN da função do Lambda é exibido.
1. (Opcional) Para **Tags**, adicione pares de chave-valor a associar com essa origem dos dados. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Próximo**.
1. Na página **Review and create** (Revisar e criar), analise os detalhes da origem dos dados e escolha **Create data source** (Criar origem dos dados).
1. A seção **Data source details** (Detalhes da origem dos dados) da página de sua origem dos dados mostra informações sobre o novo conector. Agora é possível usar o conector em suas consultas do Athena.
Para obter informações sobre como usar conectores de dados em consultas, acesse [Executar consultas federadas](running-federated-queries.md).
# Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue
Alguns conectores de fonte de dados do Athena e conexões do AWS Glue exigem uma VPC e um grupo de segurança. Este tópico mostra como criar uma VPC com uma sub-rede e um grupo de segurança para a VPC. Como parte desse processo, você recupera os IDs da VPC, da sub-rede e do grupo de segurança criados. Esses IDs são necessários quando você configura sua conexão do AWS Glue ou o conector da fonte de dados para uso com o Athena.
**Para criar uma VPC para um conector de origem de dados do Athena**
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Escolha **Criar VPC**.
1. Na página **Criar VPC**, em **Configurações da VPC**, para **Recursos a criar**, escolha **VPC e mais**.
1. Em **Geração automática da etiqueta de nome**, para **Gerar automaticamente**, insira o valor que será usado para gerar as tags de nome para todos os recursos na VPC.
1. Escolha **Criar VPC**.
1. Quando o processo for concluído, escolha **Visualizar VPC**.
1. Na seção **Details** (Detalhes), em **VPC ID** (ID da VPC), copie o ID da VPC para referência posterior.
Agora você já pode recuperar o ID de sub-rede da VPC que acabou de criar.
**Para recuperar o ID de sub-rede da VPC**
1. No painel de navegação do console da VPC, escolha **Subnets** (Sub-redes).
1. Selecione o nome de uma sub-rede cuja coluna **VPC** tenha o ID da VPC que você anotou.
1. Na seção **Details** (Detalhes), em **Subnet ID** (ID da sub-rede), copie o ID da sub-rede para referência posterior.
Em seguida, crie um grupo de segurança para a VPC.
**Para criar um grupo de segurança para a VPC**
1. No painel de navegação do console da VPC, escolha **Security** (Segurança), **Security groups** (Grupos de segurança).
1. Escolha **Criar grupo de segurança**.
1. Na página **Create Security Group** (Criar grupo de segurança), insira as informações a seguir:
+ Em **Security group name** (Nome do grupo de segurança), insira um nome para o grupo de segurança.
+ Em **Description** (Descrição), insira uma descrição para o grupo de segurança. É necessária uma descrição.
+ Em **VPC**, escolha o ID da VPC criada por você para o conector da fonte de dados.
+ Em **Inbound rules** (Regras de entrada) e **Outbound rules** (Regras de saída), adicione todas as regras de entrada e saída que precisar.
1. Escolha **Criar grupo de segurança**.
1. Na página **Details** (Detalhes) do grupo de segurança, copie o **Security group ID** (ID do grupo de segurança) para referência posterior.
## Considerações importantes sobre o uso de VPC com os conectores do Athena
As instruções a seguir se aplicam a todos os conectores do Athena, pois todos os conectores podem utilizar VPC.
**nota**
Ao usar uma VPC com conexões do AWS Glue, será necessário configurar os seguintes endpoints do PrivateLink:
Amazon S3
AWS Glue
AWS Secrets Manager
Como alternativa, você pode usar o acesso público à Internet, embora isso não seja recomendado por motivo de segurança.
**Atenção**
O uso do acesso público à Internet pode expor seus recursos a riscos de segurança adicionais. É altamente recomendável usar endpoints do PrivateLink para aumentar a segurança da configuração da VPC.
# Extrair imagens do ECR para sua conta da AWS
As funções do Lambda do conector do Athena Federation usam as imagens de contêiner que estão armazenadas no repositórios do Amazon ECR gerenciados pelo Athena. Para realizar verificações de segurança nessas imagens de contêiner, você deve primeiro copiá-las para um repositório do Amazon ECR em sua conta. Esta seção fornece instruções passo a passo sobre como copiar uma imagem para o repositório e configurar a função do Lambda para usá-la.
## Pré-requisitos
+ Um conector do Athena Federation: o conector pode ser criado por meio de qualquer fonte, desde que use uma imagem de contêiner.
**nota**
Para verificar a implantação de imagens, verifique a guia Imagem no Lambda do conector do Athena Federation
+ Docker instalado e em execução
+ AWS CLI instalada
+ Credenciais de conta com permissões de extração apropriadas
## Como transferir uma imagem
1. Localize o URI da imagem do Lambda do conector do Athena Federation
**Example**
```
account_id_1.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.15.1
```
1. Gere um token de autenticação do Docker para a conta gerenciada pelo Athena:
```
aws ecr get-login-password --region regionID | docker login --username AWS --password-stdin athena-managed-registry
```
Em que:
+ *regionID* é região da implantação (p. ex., us-east-1)
+ *athena-managed-registry* é a parte do registro do URI da imagem (por exemplo, account\$1id\$11.dkr. ecr.us-east-1.amazonaws.com)
1. Extraia a imagem da conta gerenciada pelo Athena:
```
docker pull athenaImageURI
```
1. Autentique o Docker para o registro:
```
aws ecr get-login-password --region regionID | docker login --username AWS --password-stdin customer-registry
```
Onde *customer-registry* é o registro ECR (p. ex., account\$1id\$12.dkr.ecr.us-east-1.amazonaws.com)
1. Marque a imagem extraída para a repositório:
```
docker tag athenaImageURI yourImageURI
```
1. Extraia a imagem para o repositório:
```
docker push yourImageURI
```
1. Atualize o conector do Athena Federation:
1. Navegue até a função do Lambda
1. Selecione **Implantar nova imagem**
1. Insira o URI da nova imagem
A imagem do conector federado do Athena agora se encontra em sua conta, o que permite que você execute varreduras de CVE na imagem.
# Registrar sua conexão como um Glue Data Catalog
Após criar sua fonte de dados, você poderá usar o console do Athena para registrar sua conexão como um Glue Data Catalog. Após o registro, você poderá gerenciar seu catálogo de dados federados e habilitar um controle de acesso refinado usando o Lake Formation. Para obter mais informações, consulte [Creating a federated catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-fed-catalog-data-source.html).
É possível registrar os seguintes conectores para integração com o AWS Glue a fim de oferecer um controle de acesso refinado.
+ Redshift
+ BigQuery
+ DynamoDB (pré-visualização)
+ Snowflake (pré-visualização)
+ MySQL
+ PostgreSQL
+ AWS CMDB
+ Timestream
+ Azure Data Lake Storage
+ Azure Synapse
+ IBM Db2
+ IBM Db2 AS/400 (Db2 iSeries)
+ DocumentDB
+ Google Cloud Storage
+ HBase
+ OpenSearch
+ Oracle
+ SAP HANA
+ SQL Server
+ TPC-DS
+ Cloudera Hive
+ CloudWatch
+ Cloudwatch Metrics
+ Teradata
+ Vertica
## Pré-requisitos
Antes de começar, conclua os pré-requisitos a seguir.
+ Certifique-se de que você tenha os perfis e as permissões necessários para registrar locais. Para obter mais informações, consulte [Requisitos para funções usadas para registrar locais](https://docs.aws.amazon.com/lake-formation/latest/dg/registration-role.html) no Guia do desenvolvedor do AWS Lake Formation.
+ Certifique-se de que você tenha os perfis necessários para o Lake Formation. Para obter mais informações, consulte [Prerequisites for connecting the Data Catalog to external data sources](https://docs.aws.amazon.com/lake-formation/latest/dg/federated-catalog-data-connection.html) no Guia do desenvolvedor do AWS Lake Formation.
+ O perfil que você registrar no Glue deverá ter as permissões listadas no exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/spill-prefix/*",
"arn:aws:s3:::amzn-s3-demo-bucket/spill-prefix"
]
},
{
"Sid": "lambdainvoke",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:lambda_function_name"
},
{
"Sid": "gluepolicy",
"Effect": "Allow",
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:connection/",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
+ Você é responsável por determinar e gerenciar o acesso adequado aos dados. [Com controles de acesso refinados em consultas federadas, é recomendável usar a política gerenciada AmazonAthenaFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html). Se quiser usar sua própria política, você deverá garantir que os usuários que executam consultas federadas não tenham acesso aos seguintes recursos.
+ `lambda:InvokeFunction` no conector Lambda especificado na conexão do Glue
+ Acesso à localização do bucket de derramamento no IAM
+ Acesso à conexão do Glue associada ao seu catálogo federado
+ Perfil do Lake Formation no IAM
## Registrar sua conexão usando o console
**Para registrar sua conexão como um Glue Data Catalog**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na lista **Fontes de dados**, escolha a fonte de dados que você criou para abrir a página **Detalhes da fonte de dados**.
1. Escolha **Comece a usar o AWS Lake Formation**.
**nota**
Após escolher essa opção, você deverá gerenciar sua função do Lambda por conta própria. O Athena não excluirá sua função do Lambda.
1. Em **Nome do catálogo de dados**, forneça um nome exclusivo para seu catálogo.
1. Escolha o **Perfil do IAM do Lake Formation** que concede permissão ao Lake Formation para invocar a função do Lambda. Certifique-se de que seu perfil tenha as permissões [deste exemplo](#register-connection-as-gdc-pre).
1. Na caixa de texto, digite **confirmar** para excluir a fonte de dados do Athena e substituí-la por um registro do catálogo de dados do Glue.
**nota**
Essa ação excluirá sua fonte de dados do Athena e criará um novo Glue Data Catalog em seu lugar. Após a conclusão desse processo, talvez seja necessário atualizar as consultas que acessam a fonte de dados para fazer referência ao catálogo de dados do Glue recém-criado.
1. Escolha **Criar catálogo e acessar o Lake Formation**. Isso vai abrir o console do Lake Formation, onde você poderá gerenciar o catálogo e conceder permissões aos usuários em catálogos, bancos de dados e tabelas.
# Habilitar consultas federadas entre contas
A consulta federada permite consultar as origens de dados que não são do Amazon S3 usando os conectores de origem de dados implantados no AWS Lambda. O recurso de consulta federada entre contas permite que a função do Lambda e as origens de dados a serem consultadas estejam localizadas em contas diferentes.
**nota**
Só use esse método se você não tiver registrado sua fonte de dados federada com o AWS Glue Data Catalog. Se você tiver registrado sua fonte de dados no AWS Glue Data Catalog, use o modelo de recursos e permissões entre contas do AWS Glue Data Catalog. Para mais informações, consulte [Concessão de acesso entre contas](https://docs.aws.amazon.com/glue/latest/dg/cross-account-access.html) no *Guia do usuário do AWS Glue*.
Como administrador de dados, você pode habilitar consultas federadas entre contas compartilhando seu conector de dados com uma conta de analista de dados ou, como analista de dados, usando um ARN do Lambda compartilhado de um administrador de dados para adicionar à sua conta. Quando alterações de configuração são feitas em um conector na conta de origem, a configuração atualizada é aplicada automaticamente às instâncias compartilhadas do conector nas outras contas de usuário.
## Considerações e limitações
+ O recurso de consulta federada entre contas está disponível para conectores de dados de metastore não Hive que usam uma origem de dados baseada no Lambda.
+ O recurso não está disponível para o tipo de origem de dados AWS Glue Data Catalog. Para obter informações sobre o acesso entre contas aos AWS Glue Data Catalogs, consulte [Configurar o acesso entre contas aos catálogos de dados do AWS Glue](security-iam-cross-account-glue-catalog-access.md).
+ Se a resposta da função do Lambda do conector excede o limite de tamanho de resposta do Lambda de 6 MB, o Athena automaticamente criptografa, agrupa e distribui a resposta para um bucket do Amazon S3 que você configurou. A entidade que executa a consulta do Athena deve ter acesso ao local do vazamento para que o Athena leia os dados vazados. Recomendamos definir uma política de ciclo de vida do Amazon S3 para excluir objetos do local do vazamento, pois os dados não serão necessários após a conclusão da consulta.
+ Não há suporte para o uso de consultas federadas em Regiões da AWS.
## Permissões obrigatórias
Para configurar as permissões necessárias, ações devem ser feitas na Conta A (*444455556666*) e na Conta B (*111122223333*).
### Ações para a Conta A
Para que a Conta A de administrador de dados compartilhe uma função do Lambda com a Conta B de analista de dados, a Conta B requer a função invoke do Lambda e acesso ao bucket de vazamento. Consequentemente, a Conta A deve adicionar uma [política baseada em recursos](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) à função do Lambda e acesso do [principal](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-policy-language-overview.html) ao bucket de vazamento no Amazon S3.
1. A política a seguir concede as permissões da função invoke do Lambda à Conta B em uma função do Lambda na conta A.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountInvocationStatement",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:user/username"
]
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:444455556666:function:lambda-function-name"
}
]
}
```
------
1. A política a seguir concede acesso ao bucket de vazamento a entidade principal na conta B.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": ["arn:aws:iam::111122223333:user/username"]
},
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::spill-bucket",
"arn:aws:s3:::spill-bucket/*"
]
}
]
}
```
------
1. Se a função do Lambda criptografar o bucket de vazamento com uma chave AWS KMS, em vez de usar a criptografia padrão oferecida pelo SDK da federação, a política de chave AWS KMS na conta A deverá conceder acesso ao usuário na Conta B, como no exemplo a seguir.
```
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal":
{
"AWS": ["arn:aws:iam::account-B-id:user/username"]
},
"Action": [ "kms:Decrypt" ],
"Resource": "*" // Resource policy that gets placed on the KMS key.
}
```
### Ações para a Conta B
Para que a Conta A compartilhe seu conector com a Conta B, a Conta B deve criar uma função chamada `AthenaCrossAccountCreate-account-A-id`, que a Conta A assume chamando a ação de API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) do AWS Security Token Service.
1. Use o console do IAM ou a AWS CLI para criar o perfil `AthenaCrossAccountCreate-account-A-id` como um perfil de política de confiança personalizada. Uma política de confiança personalizada delega acesso e permite que outras pessoas realizem ações na sua conta da AWS. Para ver as instruções passo a passo, consulte [Criar um perfil usando políticas de confiança personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) no *Guia de Usuário do IAM*.
A relação de confiança deve ter um objeto de entidade principal no qual a chave é `AWS` e o valor é o ARN da Conta A, como no exemplo a seguir.
```
...
"Principal":
{
"AWS": ["arn:aws:iam::account-A-id:user/username"]
},
...
```
1. Também na Conta B, crie uma política como a descrita a seguir que permita a ação `CreateDataCatalog`.
```
{
"Effect": "Allow",
"Action": "athena:CreateDataCatalog",
"Resource": "arn:aws:athena:*:account-B-id:datacatalog/*"
}
```
1. Adicione ao perfil `AthenaCrossAccountCreate-account-A-id` que você criou usando a Conta B a política que permite a ação `CreateDataCatalog`.
## Compartilhar uma origem de dados na conta A com a conta B
Após aplicar as permissões, você poderá usar a página **Fontes de dados e catálogos** no console do Athena para compartilhar um conector de dados em sua conta (Conta A) com outra conta (Conta B). A conta A mantém total controle e propriedade do conector. Quando a conta A faz alterações de configuração no conector, a configuração atualizada se aplica ao conector compartilhado na conta B.
**nota**
Você só pode compartilhar uma fonte de dados do tipo Lambda e não pode compartilhar fontes de dados que usam conexões do AWS Glue. Para obter mais informações, consulte [Conectores de fonte de dados disponíveis](connectors-available.md).
**Para compartilhar uma origem de dados do Lambda na conta A com a conta B**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. Escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha o link do conector que deseja compartilhar.
1. Na página de detalhes de uma fonte de dados do Lambda, no menu **Ações**, escolha a opção **Compartilhar** no canto superior direito.
1. Na caixa de diálogo **Compartilhar *Lambda-name* com outra conta?**, insira as informações necessárias.
+ Para **Data source name** (Nome da origem dos dados), insira o nome da origem de dados copiada como você deseja que apareça na outra conta.
+ Para **Account ID**, (ID da conta), insira o ID da conta com a qual deseja compartilhar sua origem dos dados (neste caso, Conta B).
1. Selecione **Share**. O conector de dados compartilhados que você especificou é criado na Conta B. As alterações de configuração do conector na Conta A se aplicam ao conector na Conta B.
## Adicionar uma origem de dados compartilhada da conta A à conta B
Como analista de dados, você pode receber, de um administrador de dados, o ARN de um conector para adicionar à sua conta. Você pode usar a página **Fontes de dados e catálogos** do console do Athena para adicionar o ARN do Lambda fornecido pelo administrador à sua conta.
**Para adicionar o Lambda ARN de um conector de dados compartilhado à sua conta**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação não estiver visível, escolha o menu de expansão à esquerda.
1. Escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Na página **Escolha uma fonte de dados**, escolha **Conector personalizado ou compartilhado**.
1. Escolha **Próximo**.
1. Na página **Inserir detalhes da fonte de dados**, na seção **Detalhes da conexão**, em **Selecionar ou inserir uma função do Lambda**, insira o ARN do Lambda da conta A.
1. Escolha **Próximo**.
1. Na página **Revisar e criar**, escolha **Criar fonte de dados**.
## Solução de problemas
Se você receber uma mensagem de erro informando que a Conta A não tem permissões para assumir uma função na Conta B, certifique-se de que o nome da função criada na Conta B esteja escrito corretamente e ela que tenha a política adequada anexada.
# Atualizar um conector de fonte de dados
O Athena recomenda atualizar regularmente os conectores da fonte de dados que você usa para a versão mais recente para aproveitar os novos recursos e aprimoramentos. A atualização um conector de fonte de dados inclui as etapas a seguir:
# Conexões do Glue (recomendação)
## Localizar a versão mais recente do Athena Query Federation
O número da versão mais recente dos conectores de fonte de dados do Athena corresponde à versão mais recente do Athena Query Federation. Em certos casos, as versões do GitHub podem ser um pouco mais recentes do que as disponíveis no AWS Serverless Application Repository (SAR).
**Para localizar o número da versão mais recente do Athena Query Federation**
1. Acesse o URL do GitHub [https://github.com/awslabs/aws-athena-query-federation/releases/latest](https://github.com/awslabs/aws-athena-query-federation/releases/latest).
1. Observe o número da versão no título da página principal no seguinte formato:
**Versão v** *year*.*week\$1of\$1year*.*iteration\$1of\$1week* **do Athena Query Federation **
Por exemplo, o número da **versão v2023.8.3 do Athena Query Federation** é 2023.8.3.
## Descobrir a versão do conector
Siga estas etapas para determinar qual é a versão do conector que você está usando no momento.
**Para descobrir a versão do conector**
1. Na página do console do Lambda de sua aplicação do Lambda, escolha a guia **Imagem**.
1. Na guia Imagem, localize o URI da imagem. O URI tem este formato:
```
Image_location_account.dkr.ecr.us-west-2.amazonaws.com/athena-federation-repository:Version
```
1. O número da versão no URI da imagem tem o formato `year.week_of_year.iteration_of_week` (por exemplo, `2021.42.1`). Esse número representa a versão do conector.
## Implantar uma nova versão do conector
Siga as etapas a seguir para implantar uma nova versão do conector.
**Para implantar uma nova versão de conector**
1. Encontre a versão desejada seguindo o procedimento para encontrar a versão mais recente do Athena Query Federation.
1. Na função do Lambda do conector federado, localize o ImageURI e atualize a tag para a versão desejada. Por exemplo:
From:
```
509399631660.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.15.1
```
Para:
```
509399631660.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.26.1
```
**nota**
Se sua versão atual for anterior à 2025.15.1, preste atenção a essas mudanças importantes:
O nome do repositório foi atualizado para `athena-federation-repository`
Para versões anteriores a essa atualização, a substituição de comando pode não estar definida. Você deve configurá-la como o manipulador composto.
# Conexões legadas
## Localizar a versão mais recente do Athena Query Federation
O número da versão mais recente dos conectores de fonte de dados do Athena corresponde à versão mais recente do Athena Query Federation. Em certos casos, as versões do GitHub podem ser um pouco mais recentes do que as disponíveis no AWS Serverless Application Repository (SAR).
**Para localizar o número da versão mais recente do Athena Query Federation**
1. Acesse o URL do GitHub [https://github.com/awslabs/aws-athena-query-federation/releases/latest](https://github.com/awslabs/aws-athena-query-federation/releases/latest).
1. Observe o número da versão no título da página principal no seguinte formato:
**Versão v** *year*.*week\$1of\$1year*.*iteration\$1of\$1week* **do Athena Query Federation **
Por exemplo, o número da **versão v2023.8.3 do Athena Query Federation** é 2023.8.3.
## Localizar e anotar os nomes dos recursos
Na preparação para o upgrade, é necessário localizar e anotar as seguintes informações:
1. O nome da função do Lambda para o conector.
1. As variáveis de ambiente da função do Lambda.
1. O nome da aplicação do Lambda, que gerencia a função do Lambda para o conector.
**Para localizar nomes de recursos no console do Athena**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na coluna **Nome da fonte de dados**, escolha o link para a fonte de dados do conector.
1. Na seção **Detalhes da fonte de dados**, em **Função do Lambda**, escolha o link para a função do Lambda.
![\[Escolha o link da função do Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-updating-1.png)
1. Na página **Funções**, na coluna **Nome da função**, anote o nome da função do conector.
![\[Observe o nome da função.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-updating-2.png)
1. Escolha o link do nome da função.
1. Na seção **Visão geral da função**, escolha a guia **Configuração**.
1. No painel à esquerda, escolha **Variáveis de ambiente**.
1. Na seção **Variáveis de ambiente**, anote as chaves e os valores correspondentes.
1. Mova a barra de rolagem até o topo da página.
1. Na mensagem **Esta função pertence a uma aplicação. Clique aqui para gerenciá-la**, escolha o link **Clique aqui**.
1. Na página **serverlessrepo-*your\$1application\$1name***, anote o nome da aplicação sem **serverlessrepo**. Por exemplo, se o nome da aplicação for **serverlessrepo-DynamoDbTestApp**, o nome da aplicação será **DynamoDbTestApp**.
1. Permaneça na página do console do Lambda de sua aplicação e continue com as etapas descritas em **Localizar a versão do conector que você está usando**.
## Localizar a versão do conector que está sendo usado
Siga estas etapas para localizar a versão do conector que você está usando.
**Para localizar a versão do conector que você está usando**
1. Na página do console do Lambda de sua aplicação do Lambda, escolha a guia **Implantações**.
1. Na guia **Implantações**, expanda o **Modelo do SAM**.
1. Pesquise **CodeUri**.
1. No campo **Chave**, em **CodeUri**, localize a seguinte string:
```
applications-connector_name-versions-year.week_of_year.iteration_of_week/hash_number
```
O exemplo a seguir mostra uma string do conector do CloudWatch:
```
applications-AthenaCloudwatchConnector-versions-2021.42.1/15151159...
```
1. Registre o valor de *year*.*week\$1of\$1year*.*iteration\$1of\$1week* (por exemplo, **2021.42.1**). Esta é a versão de seu conector.
## Implantar uma nova versão do seu conector
Siga as etapas a seguir para implantar uma nova versão do conector.
**Para implantar uma nova versão de seu conector**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Escolha a fonte de dados que deseja atualizar e escolha **Próximo**.
1. Na seção **Detalhes da conexão**, escolha **Criar função do Lambda**. Isso abre o console do Lambda, no qual você poderá implantar a aplicação atualizada.
![\[Página do conector no console do AWS Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-updating-3.png)
1. Como você não está de fato criando uma nova fonte de dados, pode fechar a guia do console do Athena.
1. Na página do console do Lambda do conector, execute as seguintes etapas:
1. Verifique se removeu o prefixo **serverlessrepo-** do nome da aplicação e copie o nome da aplicação no campo **Nome da aplicação**.
1. Copie o nome da função do Lambda no campo **AthenaCatalogName**. Alguns conectores chamam esse campo de **LambdaFunctionName**.
1. Copie as variáveis de ambiente que você registrou nos campos correspondentes.
1. Selecione a opção **Eu reconheço que esta aplicação cria perfis do IAM personalizados e políticas de recursos** e escolha **Implantar**.
1. Para verificar se a aplicação foi atualizada, escolha a guia **Implantações**.
A seção **Histórico de implantações** mostra que sua atualização foi concluída.
![\[Atualização do conector concluída.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connectors-updating-4.png)
1. Para confirmar o novo número da versão, você pode expandir **Modelo do SAM** como antes, localizar o **CodeUri** e verificar o número da versão do conector no campo **Chave**.
Agora é possível usar seu conector atualizado para criar consultas federadas do Athena.
# Editar ou excluir uma conexão de fonte de dados
Você pode usar o console do Athena para atualizar a descrição, o host, a porta, o banco de dados e outras propriedades de uma conexão existente. Você também pode excluir as fontes de dados do console do Athena.
## Editar uma conexão de fonte de dados
**Para editar uma conexão de fonte de dados**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha a conexão de fonte de dados que deseja editar.
1. Para os **detalhes da conexão do AWS Glue**, escolha **Editar**.
1. Escolha **Próximo**.
1. Na página **Editar **, atualize as informações conforme necessário. As propriedades disponíveis dependerão do tipo de conexão.
**nota**
Ao atualizar as propriedades de conexão para segredos, local de derramamento ou ID da chave do AWS KMS, certifique-se de que o perfil de execução do Lambda ainda tenha acesso aos recursos atualizados. Para obter mais informações, consulte [Visualizar e atualizar permissões no perfil de execução](https://docs.aws.amazon.com/lambda/latest/dg/permissions-executionrole-update.html) no Guia do desenvolvedor do AWS Lambda.
+ **Descrição**: edite a descrição de sua conexão.
+ **Host**: edite o nome de host do seu banco de dados.
+ **Porta**: edite o número da porta do seu banco de dados.
+ **Banco de dados**: edite o nome do banco de dados.
+ **Parâmetros JDBC**: edite qualquer outro parâmetro JDBC necessário para sua conexão.
+ **Segredo**: escolha ou crie um segredo do AWS Secrets Manager. Use segredos do AWS para evitar a codificação permanente de informações confidenciais em sua string de conexão JDBC. Para ter mais informações, consulte [O que é o AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) Para obter informações sobre a criação de segredos no Secrets Manager, consulte [Criação de um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) no *Guia do usuário do AWS Secrets Manager*.
Para usar o AWS Secrets Manager com consultas federadas do Athena, é necessário configurar um endpoint privado do Amazon VPC para o Secrets Manager. Para obter mais informações, consulte [Criação de um endpoint privado da VPC para o Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) no *Guia do usuário do AWS Secrets Manager*.
+ **Local de derramamento no Amazon S3**: escolha ou crie um local de bucket do Amazon S3 em sua conta para armazenar os dados que excedem os limites de tamanho de resposta da função do Lambda.
**nota**
Dados derramados não são reutilizados em execuções subsequentes e podem ser excluídos com segurança depois de 12 horas. O Athena não os exclui para você. Para gerenciar esses objetos, considere adicionar uma política de ciclo de vida de objetos que exclua dados antigos do seu bucket de derramamento do Amazon S3. Para obter mais informações, consulte [Gerenciar ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) no *Manual do usuário do Amazon S3*.
+ **Criptografia para resultados de consulta no S3**: escolha uma das seguintes opções:
+ (Padrão) **Usar chave gerada aleatoriamente**: os dados derramados no Amazon S3 são criptografados usando o modo de criptografia autenticado AES-GCM e uma chave gerada aleatoriamente.
+ **Usar uma chave do AWS KMS**: escolha ou crie uma chave de criptografia mais forte gerada pelo AWS KMS. Para obter mais informações, consulte [Criação de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) *Guia do desenvolvedor do AWS Key Management Service*.
+ **Desativar**: não criptografe dados de derramamento.
+ **Configurações de rede**: algumas conexões exigem uma nuvem privada virtual (VPC). Escolha ou crie uma VPC que tenha o armazenamento de dados que você deseja acessar, uma sub-rede e um ou mais grupos de segurança. Para obter mais informações, consulte [Criar uma VPC para um conector de fonte de dados ou conexão do AWS Glue](athena-connectors-vpc-creation.md).
**nota**
Após atualizar as propriedades de conexão para recursos como segredos, local de derramamento ou ID da chave do AWS KMS, certifique-se de que o perfil de execução do Lambda continue tendo acesso aos recursos atualizados.
Após atualizar as configurações de rede da sua conexão, certifique-se de atualizar a função do Lambda com as mesmas configurações para tornar sua conexão compatível com a fonte de dados.
Para obter informações sobre propriedades adicionais de conexão, consulte [Propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) no *Guia do usuário do AWS Glue* ou [Conectores de fonte de dados disponíveis](connectors-available.md) no *Guia do usuário do Amazon Athena*.
1. Escolha **Salvar**.
A seção **detalhes da conexão do AWS Glue** da página de sua fonte de dados mostra as informações atualizadas do conector.
## Excluir uma fonte de dados
Quando você exclui uma fonte de dados, ela exclui apenas a fonte de dados do Athena e não exclui recursos como as conexões do Glue, o perfil de execução do IAM e a função do Lambda.
**Como excluir uma fonte de dados**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha a fonte de dados que deseja excluir.
1. Escolha **Excluir**.
1. Na página **Excluir fonte de dados**, digite *confirmar* para confirmar a exclusão e escolha **Excluir**. A conclusão da exclusão da fonte de dados poderá levar algum tempo. Você receberá um alerta de operação bem-sucedida quando a fonte de dados for excluída.
# Executar consultas federadas
Depois de configurar um ou mais conectores de dados e implantá-los em sua conta, você poderá usá-los nas consultas do Athena.
## Consultar uma única fonte de dados
Os exemplos nesta seção pressupõem que você tenha configurado e implantado [Conector do Amazon Athena para o CloudWatch](connectors-cloudwatch.md) em sua conta. Use a mesma abordagem para consultar quando usar outros conectores.
**Para criar uma consulta do Athena que usa o conector do CloudWatch**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No editor de consultas do Athena, crie uma consulta SQL que use a sintaxe a seguir na cláusula `FROM`.
```
MyCloudwatchCatalog.database_name.table_name
```
### Exemplos
O exemplo a seguir usa o conector do CloudWatch no Athena para se conectar à visualização `all_log_streams` no [grupo de logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) `/var/ecommerce-engine/order-processor` do CloudWatch Logs. A visualização `all_log_streams` é uma visualização de todos os fluxos de log no grupo de logs. A consulta de exemplo limita o número de linhas retornadas a 100.
```
SELECT *
FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-processor".all_log_streams
LIMIT 100;
```
O exemplo a seguir analisa informações da mesma visualização que o exemplo anterior. O exemplo extrai o ID da ordem e o nível de log e filtra qualquer mensagem que tenha o nível `INFO`.
```
SELECT
log_stream as ec2_instance,
Regexp_extract(message '.*orderId=(\d+) .*', 1) AS orderId,
message AS order_processor_log,
Regexp_extract(message, '(.*):.*', 1) AS log_level
FROM MyCloudwatchCatalog."/var/ecommerce-engine/order-processor".all_log_streams
WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'
```
## Consultar várias fontes de dados
Usando um exemplo mais complexo, imagine uma empresa de comércio eletrônico que usa as seguintes fontes de dados para armazenar dados relacionados às compras dos clientes:
+ [Amazon RDS para MySQL](https://aws.amazon.com/rds/mysql/) para armazenar dados do catálogo de produtos
+ [Amazon DocumentDB](https://aws.amazon.com/documentdb/) para armazenar dados de conta de clientes, como endereços de e-mail e endereços de envio
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) para armazenar dados de envio e rastreamento de pedidos
Imagine que um analista de dados dessa aplicação de comércio eletrônico saiba que o tempo de entrega em algumas regiões foi afetado pelas condições climáticas locais. O analista quer saber quantos pedidos estão atrasados, onde os clientes afetados estão localizados e quais foram os produtos mais afetados. Em vez de investigar as fontes de informação separadamente, o analista usa o Athena para unir dados em uma única consulta federada.
**Example**
```
SELECT
t2.product_name AS product,
t2.product_category AS category,
t3.customer_region AS region,
count(t1.order_id) AS impacted_orders
FROM my_dynamodb.default.orders t1
JOIN my_mysql.products.catalog t2 ON t1.product_id = t2.product_id
JOIN my_documentdb.default.customers t3 ON t1.customer_id = t3.customer_id
WHERE
t1.order_status = 'PENDING'
AND t1.order_date between '2022-01-01' AND '2022-01-05'
GROUP BY 1, 2, 3
ORDER BY 4 DESC
```
## Consultar visualizações federadas
Ao consultar fontes federadas, é possível usar visualizações para ofuscar as fontes de dados subjacentes ou ocultar uniões complexas de outros analistas que consultam os dados.
### Considerações e limitações
+ As visualizações federadas necessitam do mecanismo Athena versão 3.
+ As visualizações federadas são armazenadas no AWS Glue, não na fonte de dados subjacente.
+ As visualizações federadas não são compatíveis com fontes de dados [registradas como um Glue Data Catalog](register-connection-as-gdc.md).
+ As visualizações criadas com catálogos federados devem usar uma sintaxe de nome totalmente qualificada, como no seguinte exemplo:
```
"ddbcatalog"."default"."customers"
```
+ Os usuários que executam consultas em fontes federadas devem ter permissão para consultar fontes federadas.
+ A permissão `athena:GetDataCatalog` é necessária para visualizações federadas. Para obter mais informações, consulte [Permitir acesso a consultas federadas do Athena: exemplos de política](federated-query-iam-access.md).
### Exemplos
O exemplo a seguir cria uma visualização denominada `customers` nos dados armazenados em uma fonte de dados federada.
**Example**
```
CREATE VIEW customers AS
SELECT *
FROM my_federated_source.default.table
```
O exemplo de consulta a seguir mostra uma consulta que faz referência à visualização `customers` em vez da fonte de dados federada subjacente.
**Example**
```
SELECT id, SUM(order_amount)
FROM customers
GROUP by 1
ORDER by 2 DESC
LIMIT 50
```
O exemplo a seguir cria uma visualização denominada `order_summary` que combina dados de uma fonte de dados federada e de uma fonte de dados do Amazon S3. Da fonte federada, que já foi criada no Athena, a visualização usa as tabelas `person` e `profile`. No Amazon S3, a visualização usa as tabelas `purchase` e `payment`. Para se referir ao Amazon S3, a instrução usa a palavra-chave `awsdatacatalog`. A fonte de dados federada usa a sintaxe de nome totalmente qualificada *federated\$1source\$1name*.*federated\$1source\$1database*.*federated\$1source\$1table*.
**Example**
```
CREATE VIEW default.order_summary AS
SELECT *
FROM federated_source_name.federated_source_database."person" p
JOIN federated_source_name.federated_source_database."profile" pr ON pr.id = p.id
JOIN awsdatacatalog.default.purchase i ON p.id = i.id
JOIN awsdatacatalog.default.payment pay ON pay.id = p.id
```
### Recursos adicionais
+ Para ver um exemplo de uma exibição federada que está desacoplada de sua fonte original e está disponível para análise sob demanda em um modelo multiusuário, consulte [Estenda seu data mesh com o Amazon Athena e visualizações federadas](https://aws.amazon.com/blogs/big-data/extend-your-data-mesh-with-amazon-athena-and-federated-views/) no *Blog de Big Data da AWS*.
+ Para obter mais informações sobre como trabalhar com visualizações no Athena, consulte [Trabalhar com visualizações](views.md).
# Usar consultas de passagem federadas
No Athena, você pode realizar consultas em fontes de dados federadas usando a linguagem de consulta da própria fonte de dados e enviar a consulta completa para execução na fonte de dados. Essas consultas são chamadas de consultas de passagem. Para executar consultas de passagem, você usa uma função de tabela na sua consulta do Athena. Você inclui em um dos argumentos da função de tabela a consulta de passagem que será realizada na fonte de dados. As consultas de passagem retornam uma tabela que você pode analisar usando o Athena SQL.
## Conectores compatíveis
Os seguintes conectores de fonte de dados do Athena são compatíveis com consultas de passagem.
+ [Azure Data Lake Storage](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [Cloudera Hive](connectors-cloudera-hive.md)
+ [Cloudera Impala](connectors-cloudera-impala.md)
+ [CloudWatch](connectors-cloudwatch.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [HBase](connectors-hbase.md)
+ [Google BigQuery](connectors-bigquery.md)
+ [Hortonworks](connectors-hortonworks.md)
+ [MySQL](connectors-mysql.md)
+ [Neptune](connectors-neptune.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [SQL Server](connectors-microsoft-sql-server.md)
+ [Teradata](connectors-teradata.md)
+ [Timestream](connectors-timestream.md)
+ [Vertica](connectors-vertica.md)
## Considerações e limitações
Ao usar consultas de passagem no Athena, considere os seguintes pontos:
+ A passagem de consultas só é compatível com instruções `SELECT` ou operações de leitura do Athena.
+ O desempenho da consulta poderá variar de acordo com a configuração da fonte de dados.
+ A passagem de consulta não é compatível com o controle de acesso detalhado do Lake Formation.
+ As passagens de consulta não são compatíveis com fontes de dados [registradas como um Glue Data Catalog](register-connection-as-gdc.md).
## Sintaxe
A sintaxe geral de passagem de consultas do Athena é a seguinte.
```
SELECT * FROM TABLE(catalog.system.function_name(arg1 => 'arg1Value'[, arg2 => 'arg2Value', ...]))
```
Observe o seguinte:
+ **catálogo**: o nome do conector federado ou o nome do catálogo de dados do Athena de destino.
+ **system**: o namespace que contém a função. Todas as implementações do conector Athena usam esse namespace.
+ **function\$1name**: o nome da função que envia a consulta de passagem para a fonte de dados. Isso geralmente é chamado de `query`. A combinação `catalog.system.function_name` é o caminho completo de resolução para a função.
+ **arg1, arg2 etc.**: argumentos da função. O usuário deve passá-los para a função. Na maioria dos casos, essa é a string de consulta que é passada para a fonte de dados.
Para a maioria das fontes de dados, o primeiro e único argumento é `query`, seguido pelo operador de seta `=>` e pela string de consulta.
```
SELECT * FROM TABLE(catalog.system.query(query => 'query string'))
```
Para simplificar, você pode omitir o argumento nomeado opcional `query` e o operador de seta `=>`.
```
SELECT * FROM TABLE(catalog.system.query('query string'))
```
Você pode simplificar ainda mais a consulta removendo o nome do `catalog` se a consulta for executada no contexto do catálogo de destino.
```
SELECT * FROM TABLE(system.query('query string'))
```
Se a fonte de dados exigir mais do que a string de consulta, use argumentos nomeados na ordem esperada pela fonte de dados. Por exemplo, a expressão `arg1 => 'arg1Value'` contém o primeiro argumento e seu valor. O nome *arg1* é específico da fonte de dados e pode diferir entre os conectores.
```
SELECT * FROM TABLE(
system.query(
arg1 => 'arg1Value',
arg2 => 'arg2Value',
arg3 => 'arg3Value'
));
```
O exposto acima também pode ser simplificado omitindo-se os nomes dos argumentos. Porém, você deve seguir a ordem da assinatura do método. Consulte a documentação de cada conector para obter mais informações sobre a assinatura da função.
```
SELECT * FROM TABLE(catalog.system.query('arg1Value', 'arg2Value', 'arg3Value'))
```
Você pode executar várias consultas de passagem por diferentes conectores do Athena utilizando o caminho completo de resolução da função, como no exemplo a seguir.
```
SELECT c_customer_sk
FROM TABLE (postgresql.system.query('select * from customer limit 10'))
UNION
SELECT c_customer_sk
FROM TABLE(dynamodb.system.query('select * from customer')) LIMIT 10
```
Você pode usar consultas de passagem como parte de uma visualização federada. As mesmas limitações se aplicam. Para obter mais informações, consulte [visualizações federadas de consultas](https://docs.aws.amazon.com/athena/latest/ug/running-federated-queries.html#running-federated-queries-federated-views).
```
CREATE VIEW catalog.database.ViewName AS
SELECT * FROM TABLE (
catalog.system.query('query')
)
```
Para obter informações sobre a sintaxe exata a ser usada com um determinado conector, consulte a documentação do conector individual.
### Uso de aspas
Os valores dos argumentos, incluindo a string de consulta que você transmite, devem estar entre aspas simples, como no exemplo a seguir.
```
SELECT * FROM TABLE(system.query(query => 'SELECT * FROM testdb.persons LIMIT 10'))
```
Quando a string de consulta estiver entre aspas duplas, a consulta vai falhar. A consulta a seguir falha com a mensagem de erro COLUMN\$1NOT\$1FOUND: line 1:43: Column 'select \$1 from testdb.persons limit 10' cannot be resolved.
```
SELECT * FROM TABLE(system.query(query => "SELECT * FROM testdb.persons LIMIT 10"))
```
Para escapar uma aspas simples, adicione uma aspas simples ao original (p. ex., `terry's_group` para `terry''s_group`).
## Exemplos
O exemplo de consulta a seguir envia uma consulta para uma fonte de dados. A consulta seleciona todas as colunas na tabela `customer`, limitando os resultados a 10.
```
SELECT * FROM TABLE(
catalog.system.query(
query => 'SELECT * FROM customer LIMIT 10;'
))
```
A instrução a seguir executa a mesma consulta, mas elimina o argumento nomeado opcional `query` e o operador de seta `=>`.
```
SELECT * FROM TABLE(
catalog.system.query(
'SELECT * FROM customer LIMIT 10;'
))
```
Isso também pode ser encapsulado em uma visualização federada para facilitar a reutilização. Quando usado com uma visualização, você deve usar o caminho completo de resolução da função.
```
CREATE VIEW AwsDataCatalog.default.example_view AS
SELECT * FROM TABLE (
catalog.system.query('SELECT * FROM customer LIMIT 10;')
)
```
## Optar por não usar consulta de passagem
Para desabilitar as consultas de passagem, adicione uma variável de ambiente do Lambda denominada `enable_query_passthrough` e defina-a como `false`.
# Noções básicas de qualificadores de nomes de tabelas federadas
O Athena utiliza os seguintes termos para se referir às hierarquias de objetos de dados:
+ **Fonte de dados**: um grupo de bancos de dados
+ **Banco de dados**: um grupo de tabelas
+ **Tabela**: dados organizados como um grupo de linhas ou colunas
Às vezes, esses objetos também são chamados por nomes alternativos, mas equivalentes, como:
+ Às vezes uma fonte de dados é denominada catálogo.
+ Às vezes um banco de dados é denominado esquema.
## Termos de fontes de dados federadas
Ao consultar fontes de dados federadas, a fonte de dados subjacente pode não usar a mesma terminologia do Athena. Lembre-se dessa distinção ao gravar suas consultas federadas. As seções a seguir descrevem como os termos de objetos de dados do Athena correspondem aos das fontes de dados federadas.
### Amazon Redshift
Um *banco de dados* do Amazon Redshift é um grupo de *esquemas* do Redshift que contém um grupo de *tabelas* Redshift.
****
| Athena | Redshift |
| --- | --- |
| Fonte de dados do Redshift | Uma função do Lambda do conector Redshift configurada para apontar para um database do Redshift. |
| data\$1source.database.table | database.schema.table |
Consulta de exemplo
```
SELECT * FROM
Athena_Redshift_connector_data_source.Redshift_schema_name.Redshift_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para o Redshift](connectors-redshift.md).
### Cloudera Hive
Um *servidor* ou *cluster* do Cloudera Hive é um grupo de *bancos de dados* do Cloudera Hive que contém um grupo de *tabelas* Cloudera Hive.
****
| Athena | Hive |
| --- | --- |
| Fonte de dados do Cloudera Hive | Função do Lambda do conector do Cloudera Hive configurada para apontar para um server Cloudera Hive. |
| data\$1source.database.table | server.database.table |
Consulta de exemplo
```
SELECT * FROM
Athena_Cloudera_Hive_connector_data_source.Cloudera_Hive_database_name.Cloudera_Hive_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para o Cloudera Hive](connectors-cloudera-hive.md).
### Cloudera Impala
Um *servidor* ou *cluster* do Impala é um grupo de *bancos de dados* do Impala que contém um grupo de *tabelas* Impala.
****
| Athena | Impala |
| --- | --- |
| Fonte de dados do Impala | Função do Lambda do conector do Impala configurada para apontar para um server Impala. |
| data\$1source.database.table | server.database.table |
Consulta de exemplo
```
SELECT * FROM
Athena_Impala_connector_data_source.Impala_database_name.Impala_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para o Cloudera Impala](connectors-cloudera-impala.md).
### MySQL
Um *servidor* MySQL é um grupo de *bancos de dados* MySQL que contém um grupo de *tabelas* MySQL.
****
| Athena | MySQL |
| --- | --- |
| Fonte de dados do MySQL | Função do Lambda do conector do MySQL configurada para apontar para um server MySQL. |
| data\$1source.database.table | server.database.table |
Consulta de exemplo
```
SELECT * FROM
Athena_MySQL_connector_data source.MySQL_database_name.MySQL_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para o MySQL](connectors-mysql.md).
### Oracle
Um *servidor* (ou *banco de dados*) Oracle é um grupo de *esquemas* do Oracle que contém um grupo de *tabelas* do Oracle.
****
| Athena | Oracle |
| --- | --- |
| Fonte de dados do Oracle | Função do Lambda do conector do Oracle configurada para apontar para um server Oracle. |
| data\$1source.database.table | server.schema.table |
Consulta de exemplo
```
SELECT * FROM
Athena_Oracle_connector_data_source.Oracle_schema_name.Oracle_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para Oracle](connectors-oracle.md).
### Postgres
Um *servidor* (ou *cluster*) Postgres é um grupo de *bancos de dados* do Postgres. Um *banco de dados* do Postgres é um grupo de *esquemas* do Postgres que contém um grupo de *tabelas* Postgres.
****
| Athena | Postgres |
| --- | --- |
| Fonte de dados do Postgres | Função do Lambda do conector do Postgres configurada para apontar para um server e database do Postgres. |
| data\$1source.database.table | server.database.schema.table |
Consulta de exemplo
```
SELECT * FROM
Athena_Postgres_connector_data_source.Postgres_schema_name.Postgres_table_name
```
Para obter mais informações sobre o conector, consulte [Conector do Amazon Athena para o PostgreSQL](connectors-postgresql.md).
# Desenvolver um conector de fonte de dados com uso do SDK do Athena Query Federation
Para criar seus próprios conectores de fonte de dados, você pode usar o [Athena Query Federation SDK](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). O Athena Query Federation SDK define um conjunto de interfaces e protocolos de conexão que você pode usar para permitir que o Athena delegue partes do plano de execução de consultas ao código que você escreve e implanta. O SDK inclui um conjunto de conectores e um exemplo de conector.
Conectores personalizados não usam o Glue Connections para centralizar as propriedades de configuração no Glue. A configuração da conexão é feita por meio do Lambda.
Você também pode personalizar os [conectores predefinidos](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors) do Amazon Athena para uso próprio. Você pode modificar uma cópia do código-fonte do GitHub e usar a [ferramenta de publicação do conector](https://github.com/awslabs/aws-athena-query-federation/wiki/Connector_Publish_Tool) para criar seu próprio pacote do AWS Serverless Application Repository. Depois de implantar o conector dessa maneira, você poderá usá-lo em suas consultas do Athena.
Para saber sobre como baixar o SDK e obter instruções detalhadas para gravar seu próprio conector, consulte [Example Athena connector](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-example) (Exemplo de conector do Athena) no GitHub.
# Trabalhar com conectores de fonte de dados do Athena para o Apache Spark
Alguns conectores de fonte de dados do Athena estão disponíveis como conectores DSV2 do Spark. Os nomes dos conectores DSV2 do Spark têm um sufixo `-dsv2` (por exemplo, `athena-dynamodb-dsv2`).
A seguir, os conectores DSV2 atualmente disponíveis, seu nome de classe do Spark `.format()` e os links para a documentação sobre consultas federadas do Amazon Athena correspondente:
| Conector DSV2 | Nome da classe do Spark .format() | Documentação |
| --- | --- | --- |
| athena-cloudwatch-dsv2 | com.amazonaws.athena.connectors.dsv2.cloudwatch.CloudwatchTableProvider | [CloudWatch](connectors-cloudwatch.md) |
| athena-cloudwatch-metrics-dsv2 | com.amazonaws.athena.connectors.dsv2.cloudwatch.metrics.CloudwatchMetricsTableProvider | [métricas do CloudWatch](connectors-cwmetrics.md) |
| atena-aws-cmdb-dsv2 | com.amazonaws.athena.connectors.dsv2.aws.cmdb.AwsCmdbTableProvider | [CMDB](connectors-cmdb.md) |
| atena-dynamodb-dsv2 | com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider | [DynamoDB](connectors-dynamodb.md) |
Para baixar arquivos `.jar` para os conectores DSV2, visite a página [DSV2 da consulta federada do Amazon Athena](https://github.com/awslabs/aws-athena-query-federation-dsv2) no GitHub e veja a seção **Lançamentos**, **Lançamento ****, **Ativos**.
## Especificar o jar para o Spark
Para usar os conectores DSV2 do Athena com o Spark, você envia o arquivo `.jar` do conector para o ambiente do Spark que está usando. As seções a seguir descrevem casos específicos.
### Athena para Spark
Para obter informações sobre como adicionar arquivos `.jar` personalizados e configurações personalizadas ao Amazon Athena para Apache Spark, consulte [Usar as propriedades do Spark para especificar uma configuração personalizada](notebooks-spark-custom-jar-cfg.md).
### Spark em geral
Para passar arquivo `.jar` do conector para o Spark, use o comando `spark-submit` e especifique o Aarquivo `.jar` na opção `--jars`, como no seguinte exemplo:
```
spark-submit \
--deploy-mode cluster \
--jars https://github.com/awslabs/aws-athena-query-federation-dsv2/releases/download/some_version/athena-dynamodb-dsv2-some_version.jar
```
### Spark no Amazon EMR
Para executar um comando `spark-submit` com o parâmetro `--jars` no Amazon EMR, você deve adicionar uma etapa ao cluster do Spark no Amazon. Para obter detalhes sobre como usar `spark-submit` no Amazon EMR, consulte [Adicionar uma etapa do Spark](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-submit-step.html) no *Guia de lançamento do Amazon EMR.*
### Spark para ETL do AWS Glue
Para ETL do AWS Glue, você pode passar a URL GitHub.com do arquivo `.jar` para o argumento `--extra-jars` do comando `aws glue start-job-run`. A documentação do AWS Glue descreve o parâmetro `--extra-jars` seguindo um caminho do Amazon S3, mas o parâmetro também pode usar uma URL HTTPS. Para obter mais informações, consulte [Referência de parâmetros de trabalho](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html#w5aac32c13c11) no *Guia do desenvolvedor do AWS Glue*.
## Consultar o conector no Spark
Para enviar o equivalente à sua consulta federada existente do Athena no Apache Spark, use a função `spark.sql()`. Por exemplo, suponhamos que você tenha a consulta do Athena a seguir e deseje usar no Apache Spark.
```
SELECT somecola, somecolb, somecolc
FROM ddb_datasource.some_schema_or_glue_database.some_ddb_or_glue_table
WHERE somecola > 1
```
Para realizar a mesma consulta no Spark usando o conector DSV2 do Amazon Athena para DynamoDB, use o seguinte código:
```
dynamoDf = (spark.read
.option("athena.connectors.schema", "some_schema_or_glue_database")
.option("athena.connectors.table", "some_ddb_or_glue_table")
.format("com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider")
.load())
dynamoDf.createOrReplaceTempView("ddb_spark_table")
spark.sql('''
SELECT somecola, somecolb, somecolc
FROM ddb_spark_table
WHERE somecola > 1
''')
```
## Especificar parâmetros do
As versões DSV2 dos conectores de fonte de dados Athena usam os mesmos parâmetros dos conectores de fonte de dados Athena correspondentes. Para obter informações sobre parâmetros, consulte a documentação do conector de fonte de dados do Athena correspondente.
No código do PySpark, use a sintaxe a seguir para configurar os parâmetros.
```
spark.read.option("athena.connectors.conf.parameter", "value")
```
Por exemplo, o código a seguir define o parâmetro `disable_projection_and_casing` do conector Amazon Athena para o DynamoDB como `always`.
```
dynamoDf = (spark.read
.option("athena.connectors.schema", "some_schema_or_glue_database")
.option("athena.connectors.table", "some_ddb_or_glue_table")
.option("athena.connectors.conf.disable_projection_and_casing", "always")
.format("com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider")
.load())
```
# Usar o Amazon DataZone no Athena
Você pode usar o [Amazon DataZone](https://aws.amazon.com/datazone) para compartilhar, pesquisar e descobrir dados em grande escala além dos limites organizacionais. O DataZone simplifica sua experiência em todos os serviços de análise da AWS, como o Athena, o AWS Glue e o AWS Lake Formation. Por exemplo, se você tiver petabytes de dados em diferentes fontes de dados, poderá usar o Amazon DataZone para criar agrupamentos de pessoas, dados e ferramentas com base nos casos de uso comercial. Para obter mais informações, consulte [O que é o Amazon DataZone?](https://docs.aws.amazon.com/datazone/latest/userguide/what-is-datazone.html).
No Athena, você pode usar o editor de consultas para acessar e consultar os ambientes do DataZone. Um ambiente do DataZone especifica uma combinação de projeto e domínio do DataZone. Ao usar um ambiente do DataZone no console do Athena, você assume o perfil do IAM do ambiente do DataZone e só vê os bancos de dados e as tabelas que pertencem a esse ambiente. As permissões são determinadas pelos perfis que você especifica no DataZone.
No Athena, você pode usar o seletor **Ambiente do DataZone** na página do editor de consultas para escolher um ambiente do DataZone.
**Para abrir um ambiente do DataZone no Athena**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. **No canto superior direito do console do Athena, ao lado de **Grupo de trabalho**, escolha Ambiente do DataZone**.
**nota**
A opção **Ambiente do DataZone** só está presente quando você tem um ou mais domínios disponíveis no DataZone.
![\[Escolha Ambiente do DataZone.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datazone-using-1.png)
1. Use o seletor **Ambiente do DataZone** para escolher um ambiente do DataZone.
![\[Escolha um ambiente do DataZone\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datazone-using-2.png)
1. Na caixa de diálogo **Alternar para o ambiente do DataZone**, verifique se o ambiente é o que você deseja e escolha **Alternar para o ambiente do DataZone**.
![\[Confirme a mudança para um ambiente do DataZone.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datazone-using-3.png)
Para obter mais informações sobre como começar a usar o DataZone e o Athena, consulte o tutorial [Getting started](https://docs.aws.amazon.com/datazone/latest/userguide/getting-started.html) no *Amazon DataZone User Guide*.
# Usar um metastore externa do Hive
Você pode usar o conector de dados do Amazon Athena para o metastore externo do Hive para consultar conjuntos de dados no Amazon S3 que usam um metastore do Apache Hive. Não é necessária nenhuma migração de metadados para o AWS Glue Data Catalog. No console de gerenciamento do Athena, configure uma função do Lambda para se comunicar com o metastore do Hive que está em sua VPC privada e conectá-la ao metastore. A conexão do Lambda com o metastore do Hive é protegida por um canal privado do Amazon VPC e não usa a Internet pública. Você pode usar seu próprio código de função do Lambda ou a implementação padrão do conector de dados do Athena para o metastore externo do Hive.
**Topics**
+ [Visão geral de recursos](#connect-to-a-data-source-hive-features)
+ [Fluxo de trabalho](#connect-to-data-source-hive-workflow)
+ [Considerações e limitações](#connect-to-a-data-source-hive-considerations)
+ [Conectar o Athena a um metastore do Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md)
+ [Usar o AWS Serverless Application Repository para implementar um conector de fonte de dados do Hive](connect-data-source-sar-hive.md)
+ [Conectar o Athena a um metastore do Hive com uso de um perfil de execução do IAM existente](connect-data-source-hive-existing-iam-role.md)
+ [Configurar o Athena para usar um conector de metastore do Hive implantado](connect-data-source-hive-existing-lambda.md)
+ [Omitir o nome do catálogo em consultas do metastore externo do Hive](datastores-hive-default-catalog.md)
+ [Trabalhar com visualizações do Hive](hive-views.md)
+ [Usar a AWS CLI com metastores do Hive](datastores-hive-cli.md)
+ [Modificar o conector externo do Hive metastore do Athena](datastores-hive-reference-implementation.md)
## Visão geral de recursos
Com o conector de dados do Athena para metastore externo do Hive, você pode executar as seguintes tarefas:
+ Use o console do Athena para registrar catálogos personalizados e usá-los para executar consultas.
+ Defina funções do Lambda para diferentes metastores externos do Hive e adicione-as às consultas do Athena.
+ Use o AWS Glue Data Catalog e os metastores externos do Hive na mesma consulta do Athena.
+ Especifique um catálogo no contexto de execução da consulta como o catálogo padrão atual. Isso remove a necessidade de prefixar nomes de catálogo para nomes de banco de dados em suas consultas. Em vez de usar a sintaxe `catalog.database.table`, você pode usar `database.table`.
+ Use uma variedade de ferramentas para executar consultas que fazem referência a metastores externos do Hive. Você pode usar o console do Athena, a AWS CLI, o AWS SDK, as APIs do Athena e os drivers JDBC e ODBC atualizados do Athena. Os drivers atualizados são compatíveis com catálogos personalizados.
### Suporte à API
O conector de dados do Athena para metastore externo do Hive permite operações da API de registro de catálogo e da API de metadados.
+ **Registro do catálogo**: registre catálogos personalizados para metastores externos do Hive e [origens de dados federadas](federated-queries.md).
+ **Metadados**: use as APIs de metadados para fornecer informações de banco de dados e tabela para o AWS Glue e qualquer catálogo que você registrar no Athena.
+ **Cliente JAVA SDK do Athena**: use as APIs de registro de catálogo, as APIs de metadados e o suporte para catálogos na operação `StartQueryExecution` no cliente Java SDK atualizado do Athena.
### Implementação de referência
O Athena oferece uma implementação de referência para a função do Lambda que se conecta a metastores externos do Hive. A implementação de referência é fornecida no GitHub como um projeto de código aberto no [metastore do Athena Hive](https://github.com/awslabs/aws-athena-hive-metastore).
A implementação de referência está disponível como os dois aplicativos do AWS SAM a seguir no AWS Serverless Application Repository (SAR). Você pode usar qualquer uma dessas aplicações no SAR para criar as próprias funções do Lambda.
+ `AthenaHiveMetastoreFunction`: arquivo Uber `.jar` da função do Lambda. Um "uber" JAR (também conhecido como fat JAR ou JAR com dependências) é um arquivo `.jar` com um programa Java e as respectivas dependências em um único arquivo.
+ `AthenaHiveMetastoreFunctionWithLayer`: a camada do Lambda e o arquivo `.jar` fino da função do Lambda.
## Fluxo de trabalho
O diagrama a seguir mostra como o Athena interage com o metastore externo do Hive.
![\[Como o Athena interage com o metastore externo do Hive.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-to-data-source-hive-workflow.png)
Neste fluxo de trabalho, o metastore do Hive conectado ao banco de dados está dentro da sua VPC. Você usa o Hive Server2 para gerenciar sua metastore do Hive usando a CLI do Hive.
O fluxo de trabalho para uso de metastores externos do Hive do Athena inclui as etapas a seguir.
1. Crie uma função do Lambda que conecte o Athena ao metastore do Hive que reside em sua VPC.
1. Registre um nome de catálogo exclusivo para seu metastore do Hive e um nome de função correspondente em sua conta.
1. Ao executar uma consulta DML ou DDL do Athena que usa o nome do catálogo, o mecanismo de consulta do Athena chama o nome da função do Lambda que você associou ao nome do catálogo.
1. Ao usar AWS PrivateLink, a função do Lambda se comunica com o metastore externo do Hive em sua VPC e recebe respostas às solicitações de metadados. O Athena usa os metadados do metastore externo do Hive da mesma forma que usa os metadados do padrão AWS Glue Data Catalog.
## Considerações e limitações
Ao usar o conector de dados do Athena para metastore externo do Hive, considere os seguintes pontos:
+ É possível usar CTAS para criar uma tabela em um metastore do Hive externo.
+ É possível usar INSERT INTO para inserir dados em um metastore do Hive externo.
+ O suporte de DDL para metastore externo do Hive está limitado às instruções a seguir.
+ ALTER DATABASE SET DBPROPERTIES
+ ALTER TABLE ADD COLUMNS
+ ALTER TABLE ADD PARTITION
+ ALTER TABLE DROP PARTITION
+ ALTER TABLE RENAME PARTITION
+ ALTER TABLE REPLACE COLUMNS
+ ALTER TABLE SET LOCATION
+ ALTER TABLE SET TBLPROPERTIES
+ CREATE DATABASE
+ CRIAR TABELA
+ CREATE TABLE AS
+ DESCRIBE TABLE
+ DROP DATABASE
+ DESCARTAR TABELA
+ SHOW COLUMNS
+ SHOW CREATE TABLE
+ SHOW PARTITIONS
+ SHOW SCHEMAS
+ SHOW TABLES
+ SHOW TBLPROPERTIES
+ O número máximo de catálogos registrados que é possível ter é 1.000.
+ A autenticação Kerberos para o metastore do Hive não é compatível.
+ Para usar o driver JDBC com um metastore externo do Hive ou com [consultas federadas](federated-queries.md), inclua`MetadataRetrievalMethod=ProxyAPI` na string de conexão do JDBC. Para obter informações sobre o driver JDBC, consulte [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md).
+ As colunas ocultas do Hive `$path`, `$bucket`, `$file_size`, `$file_modified_time`, `$partition` e `$row_id` não podem ser usadas para filtragem de controle de acesso detalhada.
+ Não há suporte para o controle de acesso detalhado para tabelas de sistema ocultas do Hive, como `example_table$partitions` ou `example_table$properties`.
### Permissões
Conectores de dados predefinidos e personalizados podem exigir acesso aos recursos a seguir para funcionar corretamente. Verifique as informações do conector que você usa para confirmar se você configurou a VPC corretamente. Para obter informações sobre as permissões do IAM necessárias para executar consultas e criar um conector de origem dos dados no Athena, consulte [Permitir a um metastore do Hive externo acesso a um conector de dados do Athena](hive-metastore-iam-access.md) e [Permitir acesso da função do Lambda aos metastores externos do Hive](hive-metastore-iam-access-lambda.md).
+ **Amazon S3**: além de gravar os resultados das consultas no local específico do Athena no Amazon S3, os conectores de dados gravam em um bucket de vazamento no Amazon S3. São necessárias conectividade e permissões para esse local do Amazon S3. Para obter mais informações, consulte [Local de vazamento no Amazon S3](#connect-to-data-source-hive-spill-location) mais adiante neste tópico.
+ **Athena**: o acesso é necessário para conferir o status da consulta e evitar verificação em excesso.
+ **AWS Glue**: o acesso será necessário se o conector usar AWS Glue para metadados complementares ou primários.
+ **AWS Key Management Service**
+ **Políticas**: o metastore do Hive, o Athena Query Federation e as UDFs exigem políticas além da [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy). Para obter mais informações, consulte [Gerenciamento de identidade e acesso no Athena](security-iam-athena.md).
### Local de vazamento no Amazon S3
Devido ao [limite](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) de tamanho de resposta da função do Lambda, as respostas que o ultrapassam são vazadas para um local no Amazon S3 especificado quando você cria a função do Lambda. O Athena lê essas respostas diretamente do Amazon S3.
**nota**
O Athena não remove os arquivos de resposta do Amazon S3. Recomendamos configurar uma política de retenção para excluir arquivos de resposta automaticamente.
# Conectar o Athena a um metastore do Apache Hive
Para conectar o Athena a um metastore do Apache Hive, crie e configure uma função do Lambda. Para uma implementação básica, execute todas as etapas necessárias no console de gerenciamento do Athena.
**nota**
O procedimento a seguir requer que você tenha permissão para criar uma função personalizada do IAM para a função do Lambda. Se você não tiver permissão para criar uma função personalizada, poderá usar a [implementação de referência](connect-to-data-source-hive.md#connect-to-a-data-source-hive-features-reference-implementation) do Athena para criar uma função do Lambda separadamente e, depois, usar o console do AWS Lambda para escolher uma função existente do IAM para essa função. Para obter mais informações, consulte [Conectar o Athena a um metastore do Hive com uso de um perfil de execução do IAM existente](connect-data-source-hive-existing-iam-role.md).
**Para conectar o Athena a um metastore do Hive**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. Escolha **Fontes de dados e catálogos**.
1. No canto superior direito do console, escolha **Create data source** (Criar origem dos dados).
1. Na página **Choose a data source** (Escolher uma origem dos dados), em **Data sources** (Origens de dados), escolha **S3 - Apache Hive metastore**.
1. Escolha **Próximo**.
1. Na seção **Data source details** (Detalhes da origem dos dados), em **Data source name** (Nome da origem dos dados), insira o nome que deseja usar em suas instruções SQL ao consultar a origem dos dados pelo Athena. O nome pode ter até 127 caracteres e deve ser exclusivo na sua conta. Ele não poderá ser alterado após a criação. Os caracteres válidos são a-z, A-Z, 0-9, \$1 (sublinhado), @ (arroba) e - (hífen). Os nomes `awsdatacatalog`, `hive`, `jmx` e `system` são reservados pelo Athena e não podem ser usados como nomes de origens dos dados.
1. Em **Função do Lambda**, escolha **Criar função do Lambda** e, em seguida, **Criar uma nova função do Lambda no AWS Lambda**
A página **AthenaHiveMetastoreFunction** é aberta no console do AWS Lambda. A página inclui informações detalhadas sobre o conector.
![\[A página AthenaHiveMetastoreFunction no console do AWS Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-to-data-source-hive-4.png)
1. Em **Application settings** (Configurações da aplicação), insira os parâmetros para a função do Lambda.
+ **LambdaFuncName**: especifique um nome para a função. Por exemplo, **myHiveMetastore**.
+ **SpillLocation**: especifique um local do Amazon S3 nessa conta para armazenar os metadados de vazamento, caso o tamanho da resposta da função do Lambda exceda 4 MB.
+ **HMSUris**: insira o URI do host do metastore do Hive que usa o protocolo Thrift na porta 9083. Use a sintaxe `thrift://:9083`.
+ **LambdaMemory**: especifique um valor entre 128 MB e 3008 MB. A função do Lambda aloca os ciclos de CPU proporcionalmente à quantidade de memória que você configura. O padrão é 1024.
+ **LambdaTimeout**: especifique o tempo máximo de execução de invocação do Lambda permitido em segundos de 1 a 900 (900 segundos são 15 minutos). O padrão é 300 segundos (5 minutos).
+ **VPCSecurityGroupIds**: insira uma lista separada por vírgulas de IDs de grupo de segurança da VPC para o metastore do Hive.
+ **VPCSubnetIds**: insira uma lista separada por vírgulas de IDs de sub-rede da VPC para o metastore do Hive.
1. Selecione **I acknowledge that this app creates custom IAM roles** (Eu reconheço que este aplicativo cria funções personalizadas do IAM e, em seguida, escolha **Deploy** (Implantar).
![\[Implantar a aplicação de função do Lambda pelo console do AWS Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-to-data-source-hive-4a.png)
Quando a implantação for concluída, sua função será exibida na lista de aplicações do Lambda. Agora que a função do metastore do Hive foi implantada em sua conta, você pode configurar o Athena para usá-la.
1. Retorne à página **Enter data source details** (Inserir detalhes da origem dos dados) do console do Athena.
1. Na seção **Lambda function** (Função do Lambda), escolha o ícone de atualização ao lado da caixa de pesquisa de funções do Lambda. Atualizar a lista de funções disponíveis faz com que a função recém-criada apareça na lista.
1. Escolha o nome da função que você acabou de criar no console do Lambda. O ARN da função do Lambda é exibido.
1. (Opcional) Para **Tags**, adicione pares de chave-valor a associar com essa origem dos dados. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Próximo**.
1. Na página **Review and create** (Revisar e criar), analise os detalhes da origem dos dados e escolha **Create data source** (Criar origem dos dados).
1. A seção **Data source details** (Detalhes da origem dos dados) da página de sua origem dos dados mostra informações sobre o novo conector.
Agora você poderá usar o **Data source name** (Nome da origem dos dados) especificado para fazer referência ao metastore do Hive em suas consultas SQL no Athena. Nas consultas SQL, use a seguinte sintaxe de exemplo, substituindo `hms-catalog-1` pelo nome do catálogo especificado anteriormente.
```
SELECT * FROM hms-catalog-1.CustomerData.customers
```
1. Para obter informações sobre como visualizar, editar ou excluir as origens dos dados criadas, consulte [Gerenciar suas fontes de dados](data-sources-managing.md).
# Usar o AWS Serverless Application Repository para implementar um conector de fonte de dados do Hive
Para implantar um conector de origem dos dados do Athena para Hive, você pode usar o [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) em vez de começar com o console do Athena. Use AWS Serverless Application Repository para encontrar o conector que deseja usar, forneça os parâmetros que o conector exige e implante o conector em sua conta. Depois de implantar o conector, você usa o console do Athena para disponibilizar a origem dos dados para o Athena.
**Como usar o AWS Serverless Application Repository para implantar um conector de fonte de dados do Hive em sua conta**
1. Faça login no Console de gerenciamento da AWS e abra o **Repositório de aplicativos sem servidor**.
1. No painel de navegação, escolha **Aplicativos disponíveis**.
1. Selecione a opção **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções personalizadas do IAM ou políticas de recursos).
1. Na caixa de pesquisa, insira **Hive**. Os conectores exibidos incluem estes dois:
+ **AthenaHiveMetastoreFunction**: arquivo Uber `.jar` da função do Lambda.
+ **AthenaHiveMetastoreFunctionWithLayer**: a camada do Lambda e o arquivo `.jar` fino da função do Lambda.
Os dois aplicativos têm a mesma funcionalidade e diferem apenas em sua implementação. É possível usar qualquer um para criar uma função do Lambda que conecta o Athena ao seu metastore do Hive.
1. Escolha o nome do conector que você deseja usar. Este tutorial usa **AthenaHiveMetastoreFunction**.
![\[Escolha o nome do conector de origem dos dados do Athena para Hive.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-data-source-sar-hive-1.png)
1. Em **Application settings** (Configurações da aplicação), insira os parâmetros para a função do Lambda.
+ **LambdaFuncName**: especifique um nome para a função. Por exemplo, **myHiveMetastore**.
+ **SpillLocation**: especifique um local do Amazon S3 nessa conta para armazenar os metadados de vazamento, caso o tamanho da resposta da função do Lambda exceda 4 MB.
+ **HMSUris**: insira o URI do host do metastore do Hive que usa o protocolo Thrift na porta 9083. Use a sintaxe `thrift://:9083`.
+ **LambdaMemory**: especifique um valor entre 128 MB e 3008 MB. A função do Lambda aloca os ciclos de CPU proporcionalmente à quantidade de memória que você configura. O padrão é 1024.
+ **LambdaTimeout**: especifique o tempo máximo de execução de invocação do Lambda permitido em segundos de 1 a 900 (900 segundos são 15 minutos). O padrão é 300 segundos (5 minutos).
+ **VPCSecurityGroupIds**: insira uma lista separada por vírgulas de IDs de grupo de segurança da VPC para o metastore do Hive.
+ **VPCSubnetIds**: insira uma lista separada por vírgulas de IDs de sub-rede da VPC para o metastore do Hive.
1. Na parte inferior direita da página **Application details** (Detalhes da aplicação), selecione **I acknowledge that this app creates custom IAM roles** (Eu reconheço que esta aplicação cria funções personalizadas do IAM) e escolha **Deploy** (Implantar).
Neste ponto, você pode configurar o Athena para usar sua função do Lambda para se conectar ao metastore do Hive. Para obter as etapas, consulte [Configurar o Athena para usar um conector de metastore do Hive implantado](connect-data-source-hive-existing-lambda.md).
# Conectar o Athena a um metastore do Hive com uso de um perfil de execução do IAM existente
Para conectar seu metastore externo do Hive ao Athena com uma função do Lambda que usa uma função do IAM existente, você pode usar a implementação de referência do Athena do conector Athena para o metastore externo do Hive.
Veja abaixo as três etapas principais:
1. **[Clonar e criar](#connect-data-source-hive-existing-iam-role-clone-and-build-the-lambda-function)**: clone a implementação de referência do Athena e crie o arquivo JAR que contém o código da função do Lambda.
1. **[Console do AWS Lambda](#connect-data-source-hive-existing-iam-role-aws-lambda-console)**: no console do AWS Lambda, crie uma função do Lambda, atribua a ela uma função de execução do IAM existente e carregue o código da função que você gerou.
1. **[Console do Amazon Athena](connect-data-source-hive-existing-lambda.md)**: no console do Amazon Athena, crie um nome da origem dos dados que você pode usar para referenciar o metastore externo do Hive em suas consultas do Athena.
Se você já tiver permissões para criar uma função personalizada do IAM, poderá usar um fluxo de trabalho mais simples que use o console do Athena e o AWS Serverless Application Repository para criar e configurar uma função do Lambda. Para obter mais informações, consulte [Conectar o Athena a um metastore do Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md).
## Pré-requisitos
+ O Git deve estar instalado no sistema.
+ Você deve ter o [Apache Maven](https://maven.apache.org/) instalado.
+ Você tem uma função de execução do IAM que pode atribuir à função do Lambda. Para obter mais informações, consulte [Permitir acesso da função do Lambda aos metastores externos do Hive](hive-metastore-iam-access-lambda.md).
## Clonar e criar a função do Lambda
O código da função para a implementação de referência do Athena é um projeto do Maven localizado no GitHub em [awslabs/aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore). Para obter informações detalhadas sobre o projeto, consulte o arquivo README correspondente no GitHub ou o tópico [Modificar o conector externo do Hive metastore do Athena](datastores-hive-reference-implementation.md) nesta documentação.
**Para clonar e criar o código da função do Lambda**
1. Insira o seguinte comando para clonar a implementação de referência do Athena:
```
git clone https://github.com/awslabs/aws-athena-hive-metastore
```
1. Execute este comando para criar o arquivo `.jar` para a função do Lambda:
```
mvn clean install
```
Após a compilação bem-sucedida do projeto, o seguinte arquivo `.jar` será criado na pasta de destino do projeto:
`hms-lambda-func-1.0-SNAPSHOT-withdep.jar`
Na próxima seção, use o console do AWS Lambda para carregar esse arquivo em sua conta da Amazon Web Services.
## Criar e configurar a função do Lambda no console do AWS Lambda
Nesta seção, use o console do AWS Lambda para criar uma função que aplique uma função de execução do IAM existente. Depois de configurar uma VPC para a função, carregue o código da função e configure as variáveis de ambiente dela.
### Criar a função do Lambda
Nesta etapa, crie uma função no console do AWS Lambda que use uma função do IAM existente.
**Para criar uma função do Lambda que usa uma função do IAM existente**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Selecione **Funções** no painel de navegação.
1. Escolha **Create function** (Criar função).
1. Escolha **Author from scratch** (Criar do zero).
1. Em **Function name** (Nome da função), insira o nome da sua função do Lambda (por exemplo, **EHMSBasedLambda**).
1. Em **Runtime** (Tempo de execução), escolha **Java 8**.
1. Em **Permissions** (Permissões), expanda **Change default execution role** (Alterar função de execução padrão).
1. Para **Execution role (Função de execução)**, selecione **Use an existing role (Usar uma função existente)**.
1. Em **Existing role** (Função existente), escolha a função de execução do IAM que sua função do Lambda usará com o Athena (este exemplo usa uma função chamada `AthenaLambdaExecutionRole`).
1. Expanda **Advanced settings (Configurações avançadas)**.
1. Selecione **Enable Network** (Habilitar rede).
1. Em **VPC**, escolha a VPC à qual sua função terá acesso.
1. Em **Subnets** (Sub-redes), escolha as sub-redes VPC para o Lambda usar.
1. Em **Security groups** (Grupos de segurança), escolha os grupos de segurança da VPC para o Lambda usar.
1. Escolha a opção **Criar função**. O console do AWS Lambda abre a página de configuração da sua função e começa a criá-la.
### Carregar o código e configurar a função do Lambda
Quando o console informar que sua função foi criada com êxito, você estará pronto para carregar o código da função e configurar as variáveis de ambiente.
**Para carregar o código da função do Lambda e configurar as variáveis de ambiente**
1. No console do Lambda, certifique-se de que você está na guia **Code** (Código) da página da função que você especificou.
1. Em **Code source** (Fonte do código), escolha **Upload from** (Carregar de) e escolha **.zip or jar file** (Arquivo .zip ou .jar).
1. Carregue o arquivo `hms-lambda-func-1.0-SNAPSHOT-withdep.jar` que você gerou.
1. Em sua página da função Lambda, escolha a guia **Configuration** (Configuração).
1. No painel à esquerda, escolha **Environment variables** (Variáveis de ambiente).
1. Em **Variáveis de ambiente**, selecione **Editar**.
![\[Escolha Edit para editar as variáveis de ambiente da função do Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-5.png)
1. Na página **Edit environment variables** (Editar variáveis de ambiente), use a opção **Add environment variable** (Adicionar variável de ambiente) para adicionar as seguintes chaves e valores da variável de ambiente:
+ **HMS\$1URIS**: use a sintaxe a seguir para inserir o URI do host do metastore do Hive que usa o protocolo Thrift na porta 9083.
```
thrift://:9083
```
+ **SPILL\$1LOCATION**: especifique um local do Amazon S3 na sua conta da Amazon Web Services para armazenar os metadados de vazamento, caso o tamanho da resposta da função do Lambda exceda 4 MB.
![\[Especificar valores para as variáveis de ambiente da função do Lambda.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-6.png)
1. Escolha **Salvar**.
Neste ponto, você está pronto para configurar o Athena para usar sua função do Lambda para se conectar ao metastore do Hive. Para obter as etapas, consulte [Configurar o Athena para usar um conector de metastore do Hive implantado](connect-data-source-hive-existing-lambda.md).
# Configurar o Athena para usar um conector de metastore do Hive implantado
Depois de implantar um conector de origem dos dados do Lambda em sua conta, como `AthenaHiveMetastoreFunction`, você pode configurar o Athena para usá-lo. Para isso, crie um nome de origem dos dados que faça referência a sua metastore externa do Hive para usar em suas consultas do Athena.
**Para conectar o Athena ao metastore do Hive usando uma função do Lambda existente**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. Escolha **Fontes de dados e catálogos**.
1. Na página **Fontes de dados e catálogos**, escolha **Criar fonte de dados**.
1. Na página **Choose a data source** (Escolher uma origem dos dados), em **Data sources** (Origens de dados), escolha **S3 - Apache Hive metastore**.
1. Escolha **Próximo**.
1. Na seção **Data source details** (Detalhes da origem dos dados), em **Data source name** (Nome da origem dos dados), insira o nome que deseja usar em suas instruções SQL ao consultar a origem dos dados pelo Athena (por exemplo, `MyHiveMetastore`). O nome pode ter até 127 caracteres e deve ser exclusivo na sua conta. Ele não poderá ser alterado após a criação. Os caracteres válidos são a-z, A-Z, 0-9, \$1 (sublinhado), @ (arroba) e - (hífen). Os nomes `awsdatacatalog`, `hive`, `jmx` e `system` são reservados pelo Athena e não podem ser usados como nomes de origens dos dados.
1. Na seção **Connection details** (Detalhes da conexão), use a caixa **Select or enter a Lambda function** (Selecionar ou inserir uma função do Lambda) para escolher o nome da função que você acabou de criar. O ARN da função do Lambda é exibido.
1. (Opcional) Para **Tags**, adicione pares de chave-valor a associar com essa origem dos dados. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Próximo**.
1. Na página **Review and create** (Revisar e criar), analise os detalhes da origem dos dados e escolha **Create data source** (Criar origem dos dados).
1. A seção **Data source details** (Detalhes da origem dos dados) da página de sua origem dos dados mostra informações sobre o novo conector.
Agora você poderá usar o **Data source name** (Nome da origem dos dados) especificado para fazer referência ao metastore do Hive em suas consultas SQL no Athena.
Nas consultas SQL, use a seguinte sintaxe de exemplo, substituindo `ehms-catalog` pelo nome da origem dos dados especificada anteriormente.
```
SELECT * FROM ehms-catalog.CustomerData.customers
```
1. Para visualizar, editar ou excluir as fontes de dados criadas, consulte [Gerenciar suas fontes de dados](data-sources-managing.md).
# Omitir o nome do catálogo em consultas do metastore externo do Hive
Ao executar consultas DML e DDL em metastores externos do Hive, você pode simplificar a sintaxe da consulta omitindo o nome do catálogo se esse nome estiver selecionado no editor de consulta. Certas restrições se aplicam a essa funcionalidade.
## Instruções DML
**Como executar consultas com catálogos registrados**
1. Você pode colocar o nome da origem dos dados antes do banco de dados usando a sintaxe `[[data_source_name].database_name].table_name`, como no exemplo a seguir.
```
select * from "hms-catalog-1".hms_tpch.customer limit 10;
```
1. Quando a origem dos dados que você deseja usar já estiver selecionada no editor de consultas, você poderá omitir o nome da consulta, como no exemplo a seguir.
```
select * from hms_tpch.customer limit 10:
```
![\[Uma consulta DML usando uma origem dos dados padrão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datastores-hive-default-catalog-2.png)
1. Quando você usa várias origens dos dados em uma consulta, pode omitir somente o nome da origem dos dados padrão e especificar o nome completo de qualquer origem dos dados não padrão.
Por exemplo, suponha que `AwsDataCatalog` esteja selecionado como origem dos dados padrão no editor de consultas. A instrução `FROM` no trecho de consulta a seguir qualifica totalmente os nomes das duas primeiras origens dos dados, mas omite o nome da terceira porque ela está no catálogo de dados do AWS Glue.
```
...
FROM ehms01.hms_tpch.customer,
"hms-catalog-1".hms_tpch.orders,
hms_tpch.lineitem
...
```
## Instruções DDL
As instruções DDL do Athena a seguir permitem prefixos de nome de catálogo. Prefixos de nome de catálogo em outras instruções DDL causam erros de sintaxe.
```
SHOW TABLES [IN [catalog_name.]database_name] ['regular_expression']
SHOW TBLPROPERTIES [[catalog_name.]database_name.]table_name [('property_name')]
SHOW COLUMNS IN [[catalog_name.]database_name.]table_name
SHOW PARTITIONS [[catalog_name.]database_name.]table_name
SHOW CREATE TABLE [[catalog_name.][database_name.]table_name
DESCRIBE [EXTENDED | FORMATTED] [[catalog_name.][database_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```
Assim como acontece com as instruções DML, você pode omitir a origem dos dados e os prefixos do banco de dados da consulta quando a origem dos dados e o banco de dados são selecionados no editor de consultas.
Na imagem a seguir, a origem dos dados `hms-catalog-1` e o banco de dados `hms_tpch` são selecionados no editor de consultas. A instrução `show create table customer` é bem-sucedida mesmo que o prefixo `hms-catalog-1` e o nome do banco de dados `hms_tpch` sejam omitidos da consulta em si.
![\[Uma instrução DDL que usa o catálogo padrão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datastores-hive-default-catalog-4.png)
## Especificar uma origem de dados padrão em uma string de conexão JDBC
Ao usar o driver JDBC do Athena para conectar o Athena a um metastore externo do Hive, você pode usar o parâmetro `Catalog` para especificar o nome da origem de dados padrão na string de conexão em um editor SQL, como o [SQL Workbench](https://www.sql-workbench.eu/index.html).
**nota**
Para baixar os drivers JDBC do Athena mais recentes, consulte [Usar o Athena com o driver JDBC](https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html).
A cadeia de conexão a seguir especifica a origem dos dados padrão*hms-catalog-name*.
```
jdbc:awsathena://AwsRegion=us-east-1;S3OutputLocation=s3://amzn-s3-demo-bucket/lambda/results/;Workgroup=AmazonAthenaPreviewFunctionality;Catalog=hms-catalog-name;
```
A imagem a seguir mostra um exemplo de URL de conexão JDBC como configurado no SQL Workbench.
![\[Configurar um URL de conexão JDBC no SQL Workbench.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/datastores-hive-default-catalog-jdbc-1.jpg)
# Trabalhar com visualizações do Hive
Você pode usar o Athena para consultar visualizações existentes em seus metastores externos do Apache Hive. O Athena traduz as visualizações dinamicamente em tempo de execução sem alterar a visualização original ou armazenar a tradução.
Por exemplo, suponha que você tenha uma visualização do Hive que usa uma sintaxe semelhante a `LATERAL VIEW explode()`, não compatível com o Athena, como mostrado a seguir:
```
CREATE VIEW team_view AS
SELECT team, score
FROM matches
LATERAL VIEW explode(scores) m AS score
```
O Athena traduz a string de consulta da visualização do Hive em uma instrução que o Athena pode executar, como esta:
```
SELECT team, score
FROM matches
CROSS JOIN UNNEST(scores) AS m (score)
```
Para obter informações sobre como conectar um metastore externo do Hive ao Athena, consulte [Usar um metastore externa do Hive](connect-to-data-source-hive.md).
## Considerações e limitações
Ao consultar visualizações do Hive no Athena, considere os seguintes pontos:
+ O Athena não oferece suporte à criação de visualizações do Hive. Você pode criar visualizações do Hive no seu metastore externo do Hive, que pode então ser consultado usando o Athena.
+ O Athena não oferece suporte a UDFs personalizadas para visualizações do Hive.
+ Devido a um problema conhecido no console do Athena, as visualizações do Hive aparecem na lista de tabelas, e não na lista de visualizações.
+ Embora o processo de tradução seja automático, certas funções do Hive não são compatíveis com exibições do Hive ou exigem um tratamento especial. Para obter mais informações, consulte a seção a seguir:
## Limitações de suporte às funções do Hive
Esta seção destaca as funções do Hive que não são compatíveis com visualizações do Hive no Athena ou que exigem um tratamento especial. Como o Athena atualmente oferece suporte principalmente a funções do Hive 2.2.0, funções disponíveis somente em versões superiores (como Hive 4.0.0) não são compatíveis. Para obter uma lista completa de funções do Hive, consulte o [manual de idioma de UDFs do Hive](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf).
### Funções agregadas
#### Funções agregadas que exigem tratamento especial
A função agregada a seguir para visualizações do Hive exige um tratamento especial.
+ **Avg**: em vez de `avg(INT i)`, use `avg(CAST(i AS DOUBLE))`.
#### Funções agregadas sem suporte
O Athena não oferece suporte às funções agregadas do Hive a seguir para visualizações do Hive.
```
covar_pop
histogram_numeric
ntile
percentile
percentile_approx
```
O Athena não oferece suporte a funções de regressão como `regr_count`, `regr_r2` e `regr_sxx` para visualizações do Hive.
### Funções de data sem suporte
O Athena não oferece suporte às funções de data do Hive a seguir para visualizações do Hive.
```
date_format(date/timestamp/string ts, string fmt)
day(string date)
dayofmonth(date)
extract(field FROM source)
hour(string date)
minute(string date)
month(string date)
quarter(date/timestamp/string)
second(string date)
weekofyear(string date)
year(string date)
```
### Funções de mascaramento sem suporte
O Athena não oferece suporte a funções de mascaramento do Hive como `mask()` e `mask_first_n()` para visualizações do Hive.
### Funções diversas
#### Funções diversas que exigem tratamento especial
As funções diversas para visualizações do Hive a seguir exigem tratamento especial.
+ **md5**: o Athena oferece suporte a `md5(binary)`, mas não a `md5(varchar)`.
+ **explode**: o Athena oferece suporte a `explode` quando usada com a seguinte sintaxe:
```
LATERAL VIEW [OUTER] EXPLODE()
```
+ **posexplode**: o Athena oferece suporte a `posexplode` quando usada com a seguinte sintaxe:
```
LATERAL VIEW [OUTER] POSEXPLODE()
```
Na saída `(pos, val)`, o Athena trata a coluna `pos` como `BIGINT`. Por isso, poderá ser necessário converter a coluna `pos` em `BIGINT` para evitar uma visualização obsoleta. O exemplo a seguir ilustra essa técnica.
```
SELECT CAST(c AS BIGINT) AS c_bigint, d
FROM table LATERAL VIEW POSEXPLODE() t AS c, d
```
#### Funções diversas sem suporte
O Athena não oferece suporte às funções do Hive a seguir para visualizações do Hive.
```
aes_decrypt
aes_encrypt
current_database
current_user
inline
java_method
logged_in_user
reflect
sha/sha1/sha2
stack
version
```
### Operadores
#### Operadores que exigem tratamento especial
Os operadores para visualizações do Hive a seguir exigem tratamento especial.
+ **Operador de módulo (%)**: como o tipo `DOUBLE` implicitamente converte em `DECIMAL(x,y)`, a sintaxe a seguir pode gerar uma mensagem de erro View is stale (Visualização obsoleta):
```
a_double % 1.0 AS column
```
Para contornar esse problema, use `CAST`, como no exemplo a seguir.
```
CAST(a_double % 1.0 as DOUBLE) AS column
```
+ **Operador de divisão (/)**: no Hive , `int` dividido por `int` gera um `double`. No Athena, a mesma operação gera um truncado `int`.
#### Operadores sem suporte
O Athena não oferece suporte aos operadores a seguir para visualizações do Hive.
**\$1A**: bitwise `NOT`
**A ^ b**: bitwise `XOR`
**A & b**: bitwise `AND`
**A \$1 b**: bitwise `OR`
**A <=> b**: retorna o mesmo resultado que o operador igual a (`=`) para operandos não nulos. Retornará `TRUE` se ambos forem `NULL`, ou `FALSE` se um deles for `NULL`.
### Funções de string
#### Funções de string que exigem tratamento especial
As funções de string para visualizações do Hive a seguir exigem tratamento especial.
+ **chr(bigint\$1double a)**: o Hive permite argumentos negativos; o Athena não.
+ **instr(string str, string substr)**: como o mapeamento do Athena para a função `instr` retorna `BIGINT` em vez de `INT`, use a seguinte sintaxe:
```
CAST(instr(string str, string substr) as INT)
```
Sem essa etapa, a visualização será considerada obsoleta.
+ **length(string a)**: como o mapeamento do Athena para a função `length` retorna `BIGINT` em vez de `INT`, use a seguinte sintaxe para que a visualização não seja considerada obsoleta:
```
CAST(length(string str) as INT)
```
#### Funções de string sem suporte
O Athena não oferece suporte às funções de string do Hive a seguir para visualizações do Hive.
```
ascii(string str)
character_length(string str)
decode(binary bin, string charset)
encode(string src, string charset)
elt(N int,str1 string,str2 string,str3 string,...)
field(val T,val1 T,val2 T,val3 T,...)
find_in_set(string str, string strList)
initcap(string A)
levenshtein(string A, string B)
locate(string substr, string str[, int pos])
octet_length(string str)
parse_url(string urlString, string partToExtract [, string keyToExtract])
printf(String format, Obj... args)
quote(String text)
regexp_extract(string subject, string pattern, int index)
repeat(string str, int n)
sentences(string str, string lang, string locale)
soundex(string A)
space(int n)
str_to_map(text[, delimiter1, delimiter2])
substring_index(string A, string delim, int count)
```
### Funções XPath sem suporte
O Athena não oferece suporte a funções XPath do Hive como `xpath`, `xpath_short` e `xpath_int` para visualizações do Hive.
## Solução de problemas
Ao usar visualizações do Hive no Athena, você poderá encontrar os seguintes problemas:
+ **View ** is stale** (A visualização está obsoleta): esta mensagem geralmente indica uma não correspondência de tipo entre a visualização no Hive e no Athena. Se a mesma função no [manual de idioma de UDFs do Hive](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf) e na documentação sobre [funções e operadores do Presto](https://prestodb.io/docs/current/functions.html) tiver assinaturas diferentes, tente converter o tipo de dado sem correspondência.
+ **Function not registered** (Função não registrada): o Athena atualmente não oferece suporte à função. Para obter mais informações, consulte as seções anteriores neste documento.
# Usar a AWS CLI com metastores do Hive
É possível usar os comandos da CLI `aws athena` para gerenciar os catálogos de dados do metastore do Hive que você usa com o Athena. Depois de definir um ou mais catálogos para usar com o Athena, você poderá referenciar esses catálogos em seus comandos DDL e DML `aws athena`.
## Usar a AWS CLI para gerenciar catálogos de metastore do Hive
### Registrar um catálogo: create-data-catalog
Para registrar um catálogo de dados, use o comando `create-data-catalog`. Use o parâmetro `name` para especificar o nome que você deseja usar para o catálogo. Insira o ARN da função do Lambda na opção `metadata-function` do argumento `parameters`. Para criar tags para o novo catálogo, use o parâmetro `tags` com um ou mais pares de argumentos `Key=key,Value=value` separados por espaço.
O exemplo a seguir registra o catálogo de metastore do Hive chamado `hms-catalog-1`. O comando foi formatado para legibilidade.
```
$ aws athena create-data-catalog
--name "hms-catalog-1"
--type "HIVE"
--description "Hive Catalog 1"
--parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3,sdk-version=1.0"
--tags Key=MyKey,Value=MyValue
--region us-east-1
```
### Mostrar detalhes do catálogo: get-data-catalog
Para mostrar os detalhes de um catálogo, passe o nome do catálogo para o comando `get-data-catalog`, como no exemplo a seguir.
```
$ aws athena get-data-catalog --name "hms-catalog-1" --region us-east-1
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"DataCatalog": {
"Name": "hms-catalog-1",
"Description": "Hive Catalog 1",
"Type": "HIVE",
"Parameters": {
"metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
"sdk-version": "1.0"
}
}
}
```
### Listar catálogos registrados: list-data-catalogs
Para listar os catálogos registrados, use o comando `list-data-catalogs` e, opcionalmente, especifique uma região, como no exemplo a seguir. Os catálogos listados sempre incluem o AWS Glue.
```
$ aws athena list-data-catalogs --region us-east-1
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"DataCatalogs": [
{
"CatalogName": "AwsDataCatalog",
"Type": "GLUE"
},
{
"CatalogName": "hms-catalog-1",
"Type": "HIVE",
"Parameters": {
"metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
"sdk-version": "1.0"
}
}
]
}
```
### Atualizar um catálogo: update-data-catalog
Para atualizar um catálogo de dados, use o comando `update-data-catalog`, como no exemplo a seguir. O comando foi formatado para legibilidade.
```
$ aws athena update-data-catalog
--name "hms-catalog-1"
--type "HIVE"
--description "My New Hive Catalog Description"
--parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new,sdk-version=1.0"
--region us-east-1
```
### Excluir um catálogo: delete-data-catalog
Para excluir um catálogo de dados, use o comando `delete-data-catalog`, como no exemplo a seguir.
```
$ aws athena delete-data-catalog --name "hms-catalog-1" --region us-east-1
```
### Mostrar detalhes do banco de dados: get-database
Para mostrar os detalhes de um banco de dados, passe o nome do catálogo e do banco de dados para o comando `get-database`, como no exemplo a seguir.
```
$ aws athena get-database --catalog-name hms-catalog-1 --database-name mydb
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"Database": {
"Name": "mydb",
"Description": "My database",
"Parameters": {
"CreatedBy": "Athena",
"EXTERNAL": "TRUE"
}
}
}
```
### Listar bancos de dados em um catálogo: list-databases
Para listar os bancos de dados em um catálogo, use o comando `list-databases` e, opcionalmente, especifique uma região, como no exemplo a seguir.
```
$ aws athena list-databases --catalog-name AwsDataCatalog --region us-west-2
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"DatabaseList": [
{
"Name": "default"
},
{
"Name": "mycrawlerdatabase"
},
{
"Name": "mydatabase"
},
{
"Name": "sampledb",
"Description": "Sample database",
"Parameters": {
"CreatedBy": "Athena",
"EXTERNAL": "TRUE"
}
},
{
"Name": "tpch100"
}
]
}
```
### Mostrar detalhes da tabela: get-table-metadata
Para mostrar os metadados de uma tabela, incluindo nomes de coluna e tipos de dados, passe o nome do catálogo, banco de dados e o nome da tabela para o comando `get-table-metadata`, como no exemplo a seguir.
```
$ aws athena get-table-metadata --catalog-name AwsDataCatalog --database-name mydb --table-name cityuseragent
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"TableMetadata": {
"Name": "cityuseragent",
"CreateTime": 1586451276.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "city",
"Type": "string"
},
{
"Name": "useragent1",
"Type": "string"
}
],
"PartitionKeys": [],
"Parameters": {
"COLUMN_STATS_ACCURATE": "false",
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"last_modified_by": "hadoop",
"last_modified_time": "1586454879",
"location": "s3://amzn-s3-demo-bucket/",
"numFiles": "1",
"numRows": "-1",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"rawDataSize": "-1",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"totalSize": "61"
}
}
}
```
### Visualizar metadados de todas as tabelas em um banco de dados: list-table-metadata
Para mostrar os metadados de todas as tabelas em um banco de dados, passe o nome do catálogo e do nome do banco de dados para o comando `list-table-metadata`. O comando `list-table-metadata` é semelhante ao comando `get-table-metadata`, exceto que você não especifica um nome de tabela. Para limitar o número de resultados, você pode usar a opção `--max-results`, como no exemplo a seguir.
```
$ aws athena list-table-metadata --catalog-name AwsDataCatalog --database-name sampledb --region us-east-1 --max-results 2
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"TableMetadataList": [
{
"Name": "cityuseragent",
"CreateTime": 1586451276.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "city",
"Type": "string"
},
{
"Name": "useragent1",
"Type": "string"
}
],
"PartitionKeys": [],
"Parameters": {
"COLUMN_STATS_ACCURATE": "false",
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"last_modified_by": "hadoop",
"last_modified_time": "1586454879",
"location": "s3://amzn-s3-demo-bucket/",
"numFiles": "1",
"numRows": "-1",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"rawDataSize": "-1",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"totalSize": "61"
}
},
{
"Name": "clearinghouse_data",
"CreateTime": 1589255544.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "location",
"Type": "string"
},
{
"Name": "stock_count",
"Type": "int"
},
{
"Name": "quantity_shipped",
"Type": "int"
}
],
"PartitionKeys": [],
"Parameters": {
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"location": "s3://amzn-s3-demo-bucket/",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"transient_lastDdlTime": "1589255544"
}
}
],
"NextToken": "eyJsYXN0RXZhbHVhdGVkS2V5Ijp7IkhBU0hfS0VZIjp7InMiOiJ0Ljk0YWZjYjk1MjJjNTQ1YmU4Y2I5OWE5NTg0MjFjYTYzIn0sIlJBTkdFX0tFWSI6eyJzIjoiY2xlYXJpbmdob3VzZV9kYXRhIn19LCJleHBpcmF0aW9uIjp7InNlY29uZHMiOjE1ODkzNDIwMjIsIm5hbm9zIjo2NTUwMDAwMDB9fQ=="
}
```
## Executar instruções DDL e DML
Ao usar a AWS CLI para executar instruções DDL e DML, você pode passar o nome do catálogo de metastore do Hive de uma das duas maneiras:
+ Diretamente para as declarações que são compatíveis com ele.
+ Para o parâmetro `--query-execution-context` de `Catalog`.
### Instruções DDL
O exemplo a seguir passa o nome do catálogo diretamente como parte da instrução DDL `show create table`. O comando foi formatado para legibilidade.
```
$ aws athena start-query-execution
--query-string "show create table hms-catalog-1.hms_tpch_partitioned.lineitem"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
A instrução DDL `show create table` de exemplo a seguir usa o parâmetro `Catalog` de `--query-execution-context` para passar o nome do catálogo de metastore do Hive `hms-catalog-1`. O comando foi formatado para legibilidade.
```
$ aws athena start-query-execution
--query-string "show create table lineitem"
--query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
### Instruções DML
O exemplo da instrução DML `select` a seguir passa o nome do catálogo diretamente para a consulta. O comando foi formatado para legibilidade.
```
$ aws athena start-query-execution
--query-string "select * from hms-catalog-1.hms_tpch_partitioned.customer limit 100"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
O seguinte exemplo da instrução DML `select` usa o parâmetro `Catalog` de `--query-execution-context` para passar o nome do catálogo de metastore do Hive `hms-catalog-1`. O comando foi formatado para legibilidade.
```
$ aws athena start-query-execution
--query-string "select * from customer limit 100"
--query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
# Modificar o conector externo do Hive metastore do Athena
Se você tiver requisitos especiais, poderá modificar o conector Athena para o metastore externo do Hive para seu próprio uso. O Athena oferece uma implementação de referência do conector no GitHub.com em [https://github.com/awslabs/aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore). A maioria dos casos de uso não exige que você modifique a implementação de referência. No entanto, se necessário, é possível modificar o código-fonte e criar você mesmo os artefatos.
A implementação de referência é um projeto [Apache Maven](https://maven.apache.org/) que tem os seguintes módulos:
+ `hms-service-api`: contém as operações de API entre a função do Lambda e os clientes dos serviços do Athena. Essas operações da API são definidas na interface do `HiveMetaStoreService`. Como este é um contrato de serviço, você não deve alterar nada neste módulo.
+ `hms-lambda-handler`: um conjunto de manipuladores padrão do Lambda que processa todas as chamadas de API de metastore do Hive. A classe `MetadataHandler` é o dispatcher para todas as chamadas da API. Você não precisa alterar este pacote.
+ `hms-lambda-func`: um exemplo de função do Lambda que tem os componentes a seguir.
+ `HiveMetaStoreLambdaFunc` – um exemplo de função do Lambda que estende `MetadataHandler`.
+ `ThriftHiveMetaStoreClient`: um cliente Thrift que se comunica com o metastore do Hive. Esse cliente foi escrito para o Hive 2.3.0. Se você usar uma versão diferente do Hive, talvez seja necessário atualizar essa classe para garantir que os objetos de resposta sejam compatíveis.
+ `ThriftHiveMetaStoreClientFactory`: controla o comportamento da função do Lambda. Por exemplo, você pode fornecer seu próprio conjunto de provedores de manipuladores substituindo o método `getHandlerProvider()`.
+ `hms.properties`: configura a função do Lambda. A maioria dos casos requer a atualização de apenas as duas propriedades a seguir.
+ `hive.metastore.uris` – o URI do metastore do Hive no formato `thrift://:9083`.
+ `hive.metastore.response.spill.location`: o local do Amazon S3 para armazenar objetos de resposta quando os tamanhos excedem um determinado limite (por exemplo, 4 MB). O limite é definido na propriedade `hive.metastore.response.spill.threshold`. Não é recomendável alterar o valor padrão.
**nota**
Essas duas propriedades podem ser substituídas pelas [variáveis de ambiente do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html) `HMS_URIS` e `SPILL_LOCATION`. Use essas variáveis em vez de recompilar o código-fonte da função do Lambda para usar a função com um metastore do Hive ou local de vazamento diferente.
+ `hms-lambda-layer`: um projeto de montagem do Maven que coloca `hms-service-api`, `hms-lambda-handler` e suas dependências em um arquivo `.zip`. O arquivo `.zip` é registrado como uma camada do Lambda para uso por várias funções do Lambda.
+ `hms-lambda-rnp`: registra as respostas de uma função do Lambda e, em seguida, usa-as para reproduzir a resposta. É possível usar esse modelo para simular respostas do Lambda para testes.
## Criar seus próprios artefatos
Após modificar o código-fonte, é possível criar os artefatos você mesmo e carregá-los em um local do Amazon S3.
Antes de criar os artefatos, atualize as propriedades `hive.metastore.uris` e `hive.metastore.response.spill.location` no arquivo `hms.properties` no módulo `hms-lambda-func`.
Para criar os artefatos, você deve ter o Apache Maven instalado e executar o comando `mvn install`. Isso gera o arquivo `.zip` de camada na pasta de saída chamada `target` no módulo `hms-lambda-layer` e o arquivo `.jar` da função do Lambda no módulo `hms-lambd-func`.
# Gerenciar suas fontes de dados
Você pode usar a página **Fontes de dados e catálogos** do console do Athena para gerenciar as fontes de dados que você cria.
**Como exibir uma fonte de dados**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se o painel de navegação do console não estiver visível, escolha o menu de expansão à esquerda.
![\[Escolha o menu de expansão.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/nav-pane-expansion.png)
1. No painel de navegação, escolha **Fontes de dados e catálogos**.
1. Na lista de origens dos dados, escolha o nome da origens dos dados que deseja exibir.
**nota**
Os itens na coluna **Data source name** (Nome da fonte de dados) correspondem à saída da ação da API [ListDataCatalogs](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDataCatalogs.html) e do comando da CLI [list-data-catalogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/list-data-catalogs.html).
**Como editar uma fonte de dados**
1. Na página **Fontes de dados e catálogos**, execute um dos seguintes procedimentos:
+ Selecione o botão ao lado do nome do catálogo e escolha **Actions** (Ações), **Edit** (Editar).
+ Escolha o nome da origem dos dados. Em seguida, na página de detalhes, escolha **Actions** (Ações), **Edit** (Editar).
1. Na página **Edit** (Editar), é possível escolher uma função do Lambda diferente para a origem dos dados, alterar a descrição ou adicionar etiquetas personalizadas. Para obter mais informações sobre tags, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Salvar**.
1. Para editar seu **AwsDataCatalog** na origem dos dados, escolha o link **AwsDataCatalog** para abrir a página de detalhes. Em seguida, na página de detalhes, escolha o link para o console do AWS Glue, onde você pode editar seu catálogo.
**Para compartilhar uma origem dos dados**
Para obter informações sobre como compartilhar origens dos dados, visite os links a seguir.
+ Para origens dos dados não baseadas Lambda não Hive, consulte [Habilitar consultas federadas entre contas](xacct-fed-query-enable.md).
+ Para AWS Glue Data Catalogs, veja [Configurar o acesso entre contas aos catálogos de dados do AWS Glue](security-iam-cross-account-glue-catalog-access.md).
**Como excluir uma fonte de dados**
1. Na página **Fontes de dados e catálogos**, execute um dos seguintes procedimentos:
+ Selecione o botão ao lado do nome do catálogo e escolha **Actions** (Ações), **Delete** (Excluir).
+ Escolha o nome da origem dos dados e, na página de detalhes, escolha **Actions** (Ações), **Delete** (Excluir).
**nota**
O **AwsDataCatalog** é a origem dos dados padrão da sua conta e não pode ser excluído.
Você é avisado que, ao excluir uma origem dos dados, seu catálogo de dados, tabelas e exibições correspondentes são removidos do editor de consultas. As consultas salvas que usavam a origem dos dados não serão mais executadas no Athena.
1. Para confirmar a exclusão, digite o nome da origem dos dados e escolha **Delete** (Excluir).