"
]
}
]
}
```
------
# Usar chaves de contexto CalledVia para o Athena
Quando uma [entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) faz uma [solicitação](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-request) à AWS, a AWS reúne as informações da solicitação em um *contexto de solicitação* que a avalia e autoriza a solicitação. É possível usar o elemento `Condition` de uma política JSON para comparar chaves no contexto da solicitação com os valores de chave especificados em sua política. As *chaves de contexto de condição global* são chaves de condição com um prefixo `aws:`.
## Sobre a chave de contexto aws:CalledVia
Você pode usar a chave de contexto de condição global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-calledvia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-calledvia) para comparar os serviços na política com os serviços que fazem solicitações em nome do principal do IAM (usuário ou função). Quando uma entidade principal faz uma solicitação a um AWS service (Serviço da AWS), esse serviço pode usar as credenciais do principal para fazer solicitações subsequentes a outros serviços. A chave `aws:CalledVia` contém uma lista ordenada de cada serviço na cadeia que fez solicitações em nome do principal.
Ao especificar um nome de elemento principal de serviço para a chave de contexto `aws:CalledVia`, você pode tornar a chave de contexto específica do AWS service (Serviço da AWS). Por exemplo, você pode usar a chave de condição `aws:CalledVia` para limitar as solicitações somente àquelas feitas pelo Athena. Para usar a chave de condição `aws:CalledVia` em uma política com o Athena, especifique o nome do principal do serviço do Athena `athena.amazonaws.com`, como mostrado no exemplo a seguir.
```
...
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
...
```
Você pode usar a chave de contexto `aws:CalledVia` para garantir que os autores da chamada só tenham acesso a um recurso (como uma função do Lambda) se o chamarem pelo Athena.
**nota**
A chave de contexto `aws:CalledVia` não é compatível com o recurso de propagação de identidade confiável.
## Adicionar uma chave de contexto CalledVia para acesso às funções do Lambda
O Athena exige que o autor da chamada tenha as permissões `lambda:InvokeFunction` para invocar a função do Lambda associada à consulta. A Instrução a seguir especifica que o usuário só pode invocar as funções do Lambda no Athena.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:OneAthenaLambdaFunction",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
}
]
}
```
------
O exemplo a seguir mostra a adição da instrução anterior a uma política que permite a um usuário executar e ler uma consulta federada. Os principais com permissão para realizar essas ações podem executar consultas que especificam catálogos do Athena associados a uma origem dos dados federada. No entanto, o principal não pode acessar a função do Lambda associada, a menos que ela seja invocada pelo Athena.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"athena:GetWorkGroup",
"s3:PutObject",
"s3:GetObject",
"athena:StartQueryExecution",
"s3:AbortMultipartUpload",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:athena:*:111122223333:workgroup/WorkGroupName",
"arn:aws:s3:::MyQueryResultsBucket/*",
"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::MyLambdaSpillBucket"
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": [
"arn:aws:lambda:*:111122223333:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction"
],
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": "athena.amazonaws.com"
}
}
}
]
}
```
------
Para obter mais informações sobre as chaves de condição `CalledVia`, consulte [Chaves de contexto de condição global AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Manual do usuário do IAM*.
# Permitir a um metastore do Hive externo acesso a um conector de dados do Athena
Os exemplos de política de permissão neste tópico demonstram as ações permitidas necessárias e os recursos para os quais são permitidas. Examine essas políticas com atenção e modifique-as de acordo com seus requisitos antes de anexar políticas de permissões semelhantes às identidades do IAM.
+ [Example Policy to Allow an IAM Principal to Query Data Using Athena Data Connector for External Hive Metastore](#hive-using-iam)
+ [Example Policy to Allow an IAM Principal to Create an Athena Data Connector for External Hive Metastore](#hive-creating-iam)
**Example : permitir que uma entidade principal do IAM consulte dados usando o conector de dados do Athena para metastore externo do Hive**
A política a seguir é anexada aos principais do IAM, além de [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), que concede acesso completo às ações do Athena.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"lambda:GetFunction",
"lambda:GetLayerVersion",
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:layer:MyAthenaLambdaLayer:*"
]
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation"
}
]
}
```
**Explicação de permissões**
| Ações permitidas | Explicação |
| --- | --- |
| "s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
| As ações do `s3` permitem ler e gravar no recurso especificado como `"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation"`, em que *MyLambdaSpillLocation* identifica o bucket de vazamento que foi definido na configuração da(s) função(ões) do Lambda invocada(s). O identificador do recurso *arn:aws:lambda:\$1:*MyAWSAcctId*:layer:*MyAthenaLambdaLayer*:\$1* é necessário somente se você usa uma camada do Lambda para criar dependências de tempo de execução personalizadas para reduzir o tamanho do artefato da função no momento da implantação. O `*` na última posição é um curinga para a versão da camada. |
| "lambda:GetFunction",
"lambda:GetLayerVersion",
"lambda:InvokeFunction"
| Permite que as consultas chamem as funções do AWS Lambda especificadas no bloco Resource. Por exemplo, arn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, em que MyAthenaLambdaFunction especifica o nome da função do Lambda que será invocada. Várias funções podem ser especificadas conforme mostrado no exemplo. |
**Example : permitir que uma entidade principal do IAM crie um conector de dados do Athena para metastore externo do Hive**
A política a seguir é anexada aos principais do IAM, além de [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), que concede acesso completo às ações do Athena.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:GetFunction",
"lambda:ListFunctions",
"lambda:GetLayerVersion",
"lambda:InvokeFunction",
"lambda:CreateFunction",
"lambda:DeleteFunction",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion",
"lambda:UpdateFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:DeleteFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:111122223333: function: MyAthenaLambdaFunctionsPrefix*"
}
]
}
```
**Explicação de permissões**
Permite que as consultas chamem as funções do AWS Lambda para as funções do AWS Lambda especificadas no bloco `Resource`. Por exemplo, `arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction`, em que *MyAthenaLambdaFunction* especifica o nome da função do Lambda que será invocada. Várias funções podem ser especificadas conforme mostrado no exemplo.
# Permitir acesso da função do Lambda aos metastores externos do Hive
Para invocar uma função do Lambda em sua conta, você deve criar uma função que tenha as seguintes permissões:
+ `AWSLambdaVPCAccessExecutionRole`: uma permissão de [função de execução do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) para gerenciar interfaces de rede elásticas que conectam a função a uma VPC. Verifique se você tem um número suficiente de interfaces de rede e endereços IP disponíveis.
+ `AmazonAthenaFullAccess`: a política gerenciada [AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy) concede acesso completo ao Athena.
+ Uma política do Amazon S3 para permitir que a função do Lambda grave no S3 e que o Athena leia o S3.
Por exemplo, a política a seguir define a permissão para o local de vazamento `s3:\\mybucket\spill`.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:PutObject" ], "Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/spill" ] } ] }
```
------
Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
## Criar funções do Lambda
Para criar uma função do Lambda em sua conta, são necessárias as permissões de desenvolvimento de função ou a função `AWSLambdaFullAccess`. Para obter mais informações, consulte [Políticas do IAM baseadas em identidade para o AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html).
Como o Athena usa o AWS Serverless Application Repository para criar funções do Lambda, o superusuário ou administrador que cria as funções do Lambda também deve ter políticas do IAM [para permitir consultas federadas do Athena](federated-query-iam-access.md).
## Configurar permissões para operações de API de metadados e registro de catálogo
Para acesso de API a operações de metadados e registro de catálogo, use a [política gerenciada AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy). Se você não usar a política `AmazonAthenaFullAccess`, adicione as seguintes operações de API às políticas do Athena:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:GetDataCatalog",
"athena:CreateDataCatalog",
"athena:UpdateDataCatalog",
"athena:DeleteDataCatalog",
"athena:GetDatabase",
"athena:ListDatabases",
"athena:GetTableMetadata",
"athena:ListTableMetadata"
],
"Resource": [
"*"
]
}
]
}
```
------
## Chamar uma função do Lambda entre regiões
Por padrão, o Athena invoca as funções do Lambda definidas na mesma região. Para invocar uma função do Lambda em uma Região da AWS que não é a região em que você está executando as consultas do Athena, use o ARN completo da função do Lambda.
O exemplo a seguir mostra como um catálogo na região Europa (Frankfurt) pode especificar uma função do Lambda na região Leste dos EUA (Norte da Virgínia) para buscar dados do metastore do Hive na região Europa (Frankfurt).
```
arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
```
Quando você especificar o ARN completo dessa maneira, o Athena poderá chamar a função do Lambda `external-hms-service-new` em `us-east-1` para buscar os dados do metastore do Hive de `eu-central-1`.
**nota**
O catálogo deve estar registrado na mesma Região da AWS que você usa para executar as consultas do Athena.
## Chamar uma função do Lambda entre contas
Às vezes, poderá ser necessário ter acesso a um metastore do Hive por meio de outra conta. Por exemplo, para executar um metastore do Hive, você poderia usar uma conta diferente da que usa para as consultas do Athena. Grupos ou equipes diferentes podem executar o metastore do Hive com contas diferentes dentro de sua VPC. Ou você pode querer acessar metadados de diferentes metastores do Hive de diferentes grupos ou equipes.
O Athena usa o [suporte do AWS Lambda ao acesso entre contas](https://aws.amazon.com/blogs/compute/easy-authorization-of-aws-lambda-functions/) para habilitar o acesso entre contas aos metastores do Hive.
**nota**
Observe que, normalmente, o acesso entre contas para o Athena implica no acesso entre contas para os metadados e os dados no Amazon S3.
Imagine o seguinte cenário:
+ A conta `111122223333` configura a função do Lambda `external-hms-service-new` em us-east-1 no Athena para acessar um metastore do Hive executado em um cluster do EMR.
+ A conta `111122223333` deseja permitir que a conta 444455556666 acesse os dados do metastore do Hive.
Para conceder acesso da conta `444455556666` à função do Lambda `external-hms-service-new`, a conta `111122223333` usa o comando da AWS CLI `add-permission` a seguir. O comando foi formatado para legibilidade.
```
$ aws --profile perf-test lambda add-permission
--function-name external-hms-service-new
--region us-east-1
--statement-id Id-ehms-invocation2
--action "lambda:InvokeFunction"
--principal arn:aws:iam::444455556666:user/perf1-test
{
"Statement": "{\"Sid\":\"Id-ehms-invocation2\",
\"Effect\":\"Allow\",
\"Principal\":{\"AWS\":\"arn:aws:iam::444455556666:user/perf1-test\"},
\"Action\":\"lambda:InvokeFunction\",
\"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new\"}"
}
```
Para verificar a permissão do Lambda, use o comando `get-policy`, como no exemplo a seguir. O comando foi formatado para legibilidade.
```
$ aws --profile perf-test lambda get-policy
--function-name arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
--region us-east-1
{
"RevisionId": "711e93ea-9851-44c8-a09f-5f2a2829d40f",
"Policy": "{\"Version\":\"2012-10-17\",
\"Id\":\"default\",
\"Statement\":[{\"Sid\":\"Id-ehms-invocation2\",
\"Effect\":\"Allow\",
\"Principal\":{\"AWS\":\"arn:aws:iam::444455556666:user/perf1-test\"},
\"Action\":\"lambda:InvokeFunction\",
\"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new\"}]}"
}
```
Depois de adicionar a permissão, você poderá usar um ARN completo da função do Lambda em `us-east-1`, conforme mostrado abaixo, ao definir o catálogo `ehms`:
```
arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new
```
Para obter informações sobre invocação entre regiões, consulte [Chamar uma função do Lambda entre regiões](#hive-metastore-iam-access-lambda-cross-region-invocation) anteriormente neste tópico.
### Conceder o acesso entre contas aos dados
Antes de executar consultas do Athena, você deve conceder acesso entre contas aos dados no Amazon S3. Você pode fazer isso por meio de uma das seguintes maneiras:
+ Atualize a política da lista de controle de acesso do bucket do Amazon S3 com um [ID de usuário canônico](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html).
+ Adicione o acesso entre contas à política de bucket do Amazon S3.
Por exemplo, adicione a política a seguir à política de bucket do Amazon S3 na conta `111122223333` para permitir que a conta `444455556666` leia os dados do local do Amazon S3 especificado.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1234567890123", "Effect":
"Allow", "Principal": { "AWS":
"arn:aws:iam::444455556666:user/perf1-test"
}, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::athena-test/lambda/dataset/*" } ]
}
```
------
**nota**
Talvez seja necessário conceder acesso entre contas ao Amazon S3, não apenas aos dados, mas também ao local de vazamento do Amazon S3. A função do Lambda vaza os dados excedentes para o local de vazamento quando o tamanho do objeto de resposta ultrapassa um determinado limite. Consulte o início deste tópico para obter uma política de exemplo.
No exemplo atual, após o acesso entre contas ser concedido a `444455556666,`, `444455556666` pode usar o catálogo `ehms` em sua própria `account` para consultar tabelas definidas na conta `111122223333`.
No exemplo a seguir, o perfil do SQL Workbench `perf-test-1` é para a conta `444455556666`. A consulta usa o catálogo `ehms` para acessar o metastore do Hive e os dados do Amazon S3 na conta `111122223333`.
![\[Acesso ao metastore do Hive e aos dados do Amazon S3 entre contas no SQL Workbench.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/hive-metastore-iam-access-lambda-1.png)
# Permissões necessárias para criar o conector e o catálogo do Athena
Para invocar `CreateDataCatalog` do Athena, você deverá criar um perfil que tenha as seguintes permissões:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"glue:TagResource",
"glue:GetConnection",
"glue:CreateConnection",
"glue:DeleteConnection",
"glue:UpdateConnection",
"serverlessrepo:CreateCloudFormationTemplate",
"serverlessrepo:GetCloudFormationTemplate",
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:DescribeStacks",
"cloudformation:CreateChangeSet",
"cloudformation:DescribeAccountLimits",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate",
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:EstimateTemplateCost",
"cloudformation:ListImports",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:DeleteFunction",
"lambda:CreateFunction",
"lambda:TagResource",
"lambda:ListFunctions",
"lambda:GetAccountSettings",
"lambda:ListEventSourceMappings",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:AddPermission",
"lambda:ListTags",
"lambda:GetAlias",
"lambda:GetPolicy",
"lambda:ListAliases",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"secretsmanager:ListSecrets",
"glue:GetCatalogs"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:DetachRolePolicy",
"iam:DeleteRolePolicy",
"iam:PutRolePolicy",
"iam:GetRolePolicy",
"iam:CreateRole",
"iam:TagRole",
"iam:DeleteRole",
"iam:GetRole",
"iam:PassRole",
"iam:ListRoles",
"iam:ListAttachedRolePolicies",
"iam:ListRolePolicies",
"iam:GetPolicy",
"iam:UpdateRole"
],
"Resource": [
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
}
]
}
```
------
# Permitir acesso a consultas federadas do Athena: exemplos de política
Os exemplos de política de permissão neste tópico demonstram as ações permitidas necessárias e os recursos para os quais são permitidas. Examine essas políticas com atenção e modifique-as de acordo com suas necessidades antes de anexá-las às identidades do IAM.
Para obter informações sobre como anexar políticas a identidades do IAM, consulte [Adicionar e remover permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no [Guia do usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
+ [Example policy to allow an IAM principal to run and return results using Athena Federated Query](#fed-using-iam)
+ [Example Policy to Allow an IAM Principal to Create a Data Source Connector](#fed-creating-iam)
**Example : permitir que uma entidade principal do IAM execute e retorne resultados usando a consulta federada do Athena**
A política de permissões baseadas em identidade a seguir permite ações que um usuário ou outro principal do IAM precisa para usar a consulta federada do Athena. Os principais que têm permissão para realizar essas ações podem executar consultas que especificam catálogos do Athena associados a uma origem dos dados federada.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Athena",
"Effect": "Allow",
"Action": [
"athena:GetDataCatalog",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
],
"Resource": [
"arn:aws:athena:*:111122223333:workgroup/WorkgroupName",
"arn:aws:athena:us-east-1:111122223333:datacatalog/DataCatalogName"
]
},
{
"Sid": "ListAthenaWorkGroups",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
},
{
"Sid": "Lambda",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": [
"arn:aws:lambda:*:111122223333:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:111122223333:function:AnotherAthenaLambdaFunction"
]
},
{
"Sid": "S3",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListMultipartUploadParts",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::MyLambdaSpillBucket",
"arn:aws:s3:::MyLambdaSpillBucket/*",
"arn:aws:s3:::MyQueryResultsBucket",
"arn:aws:s3:::MyQueryResultsBucket/*"
]
}
]
}
```
**Explicação de permissões**
| Ações permitidas | Explicação |
| --- | --- |
| "athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
| Permissões do Athena necessárias para executar consultas federadas. |
| "athena:GetDataCatalog",
"athena:GetQueryExecution,"
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
| Permissões do Athena necessárias para executar consultas de visualizações federadas. A ação `GetDataCatalog` é necessária para exibições. |
| "lambda:InvokeFunction"
| Permite que as consultas chamem as funções do AWS Lambda para as funções do AWS Lambda especificadas no bloco Resource. Por exemplo, arn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, em que MyAthenaLambdaFunction especifica o nome da função do Lambda que será invocada. Como apresentado no exemplo, é possível especificar várias funções. |
| "s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListMultipartUploadParts",
"s3:PutObject"
| É necessário ter as permissões `s3:ListBucket` e `s3:GetBucketLocation` para acessar o bucket de saída da consulta para entidades principais do IAM que executam `StartQueryExecution`. `s3:PutObject`, `s3:ListMultipartUploadParts` e `s3:AbortMultipartUpload` permitem gravar os resultados de consultas em todas as subpastas do bucket de resultados de consultas, conforme especificado pelo identificador de recurso `arn:aws:s3:::MyQueryResultsBucket/*`, com *MyQueryResultsBucket* indicando o bucket de resultados de consulta do Athena. Para obter mais informações, consulte [Trabalhar com resultados de consultas e consultas recentes](querying.md). `s3:GetObject` permite ler os resultados e o histórico de consultas para o recurso especificado como `arn:aws:s3:::MyQueryResultsBucket`, em que *MyQueryResultsBucket* é o bucket de resultados de consultas do Athena. `s3:GetObject` também permite ler o recurso especificado como `"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"`, em que *MyLambdaSpillPrefix* foi especificado na configuração da(s) função(ões) do Lambda invocada(s). |
**Example : permitir que uma entidade principal do IAM crie um conector de origem de dados**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"iam:CreateRole",
"lambda:GetFunctionConfiguration",
"iam:AttachRolePolicy",
"iam:PutRolePolicy",
"lambda:PutFunctionConcurrency",
"iam:PassRole",
"iam:DetachRolePolicy",
"lambda:ListTags",
"iam:ListAttachedRolePolicies",
"iam:DeleteRolePolicy",
"lambda:DeleteFunction",
"lambda:GetAlias",
"iam:ListRolePolicies",
"iam:GetRole",
"iam:GetPolicy",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"iam:DeleteRole",
"lambda:UpdateFunctionCode",
"s3:GetObject",
"lambda:AddPermission",
"iam:UpdateRole",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"iam:GetRolePolicy",
"lambda:GetPolicy"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunctionsPrefix*",
"arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/*",
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:ListImports",
"lambda:ListFunctions",
"iam:ListRoles",
"lambda:GetAccountSettings",
"ec2:DescribeSecurityGroups",
"cloudformation:EstimateTemplateCost",
"ec2:DescribeVpcs",
"lambda:ListEventSourceMappings",
"cloudformation:DescribeAccountLimits",
"ec2:DescribeSubnets",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/aws-serverless-repository-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:111122223333:stack/serverlessrepo-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:*:transform/Serverless-*",
"arn:aws:cloudformation:*:111122223333:stackset/aws-serverless-repository-MyCFStackPrefix*:*",
"arn:aws:cloudformation:*:111122223333:stackset/serverlessrepo-MyCFStackPrefix*:*"
]
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "serverlessrepo:*",
"Resource": "arn:aws:serverlessrepo:*:*:applications/*"
},
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
}
]
}
```
**Explicação de permissões**
| Ações permitidas | Explicação |
| --- | --- |
| "lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:ListTags",
"lambda:DeleteFunction",
"lambda:GetAlias",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:AddPermission",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:GetPolicy"
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListEventSourceMappings",
| Permita a criação e gerenciamento de funções do Lambda listadas como recursos. No exemplo, um prefixo de nome é usado no identificador de recurso `arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*`, onde `MyAthenaLambdaFunctionsPrefix` é um prefixo compartilhado usado no nome de um grupo de funções do Lambda para que não precisem ser especificadas individualmente como recursos. É possível especificar um ou mais recursos de função do Lambda. |
| "s3:GetObject"
| Permite a leitura de um bucket de que o AWS Serverless Application Repository precisa conforme especificado pelo identificador de recurso arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/\$1. Esse bucket pode ser específico para sua conta. |
| "cloudformation:*"
| Permite a criação e o gerenciamento de pilhas especificadas do CloudFormation pelo recurso `MyCFStackPrefix`. Essas pilhas e conjuntos de pilhas são como o AWS Serverless Application Repository implanta conectores e UDFs. |
| "serverlessrepo:*"
| Permite pesquisar, exibir, publicar e atualizar aplicativos no AWS Serverless Application Repository, especificados pelo identificador de recurso arn:aws:serverlessrepo:\$1:\$1:applications/\$1. |
| "ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
| Permite que a função do Lambda criada acesse a imagem do ECR do conector da federação. |
# Permitir acesso a UDFs do Athena: exemplos de políticas
Os exemplos de política de permissão neste tópico demonstram as ações permitidas necessárias e os recursos para os quais são permitidas. Examine essas políticas com atenção e modifique-as de acordo com seus requisitos antes de anexar políticas de permissões semelhantes às identidades do IAM.
+ [Example Policy to Allow an IAM Principal to Run and Return Queries that Contain an Athena UDF Statement](#udf-using-iam)
+ [Example Policy to Allow an IAM Principal to Create an Athena UDF](#udf-creating-iam)
**Example : permitir que uma entidade principal do IAM execute e retorne consultas com uma instrução de UDF do Athena**
A seguinte política de permissões baseada em identidade permite ações que um usuário ou outro principal do IAM precisa para executar consultas que usam instruções de UDF do Athena.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"lambda:InvokeFunction",
"athena:GetQueryResults",
"s3:ListMultipartUploadParts",
"athena:GetWorkGroup",
"s3:PutObject",
"s3:GetObject",
"s3:AbortMultipartUpload",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:athena:*:MyAWSAcctId:workgroup/MyAthenaWorkGroup",
"arn:aws:s3:::MyQueryResultsBucket/*",
"arn:aws:lambda:*:MyAWSAcctId:function:OneAthenaLambdaFunction",
"arn:aws:lambda:*:MyAWSAcctId:function:AnotherAthenaLambdaFunction"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "athena:ListWorkGroups",
"Resource": "*"
}
]
}
```
**Explicação de permissões**
| Ações permitidas | Explicação |
| --- | --- |
| "athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:GetWorkGroup",
"athena:StopQueryExecution",
"athena:GetQueryExecution",
| Permissões do Athena necessárias para executar consultas no grupo de trabalho `MyAthenaWorkGroup`. |
| "s3:PutObject",
"s3:GetObject",
"s3:AbortMultipartUpload"
| `s3:PutObject` e `s3:AbortMultipartUpload` permitem gravar os resultados de consultas em todas as subpastas do bucket de resultados de consultas, conforme especificado pelo identificador do recurso `arn:aws:s3:::MyQueryResultsBucket/*`, em que *MyQueryResultsBucket* é o bucket de resultados de consultas do Athena. Para obter mais informações, consulte [Trabalhar com resultados de consultas e consultas recentes](querying.md). `s3:GetObject` permite ler os resultados e o histórico de consultas para o recurso especificado como `arn:aws:s3:::MyQueryResultsBucket`, em que *MyQueryResultsBucket* é o bucket de resultados de consultas do Athena. Para obter mais informações, consulte [Trabalhar com resultados de consultas e consultas recentes](querying.md). `s3:GetObject` também permite ler o recurso especificado como `"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*"`, em que *MyLambdaSpillPrefix* foi especificado na configuração da(s) função(ões) do Lambda invocada(s). |
| "lambda:InvokeFunction"
| Permite que as consultas chamem as funções do AWS Lambda especificadas no bloco Resource. Por exemplo, arn:aws:lambda:\$1:MyAWSAcctId:function:MyAthenaLambdaFunction, em que MyAthenaLambdaFunction especifica o nome da função do Lambda que será invocada. Várias funções podem ser especificadas conforme mostrado no exemplo. |
**Example : permitir que uma entidade principal do IAM crie uma UDF do Athena**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"iam:CreateRole",
"lambda:GetFunctionConfiguration",
"iam:AttachRolePolicy",
"iam:PutRolePolicy",
"lambda:PutFunctionConcurrency",
"iam:PassRole",
"iam:DetachRolePolicy",
"lambda:ListTags",
"iam:ListAttachedRolePolicies",
"iam:DeleteRolePolicy",
"lambda:DeleteFunction",
"lambda:GetAlias",
"iam:ListRolePolicies",
"iam:GetRole",
"iam:GetPolicy",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"iam:DeleteRole",
"lambda:UpdateFunctionCode",
"s3:GetObject",
"lambda:AddPermission",
"iam:UpdateRole",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"iam:GetRolePolicy",
"lambda:GetPolicy"
],
"Resource": [
"arn:aws:lambda:*:111122223333:function:MyAthenaLambdaFunctionsPrefix*",
"arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/*",
"arn:aws:iam::*:role/RoleName",
"arn:aws:iam::111122223333:policy/*"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"cloudformation:CreateUploadBucket",
"cloudformation:DescribeStackDriftDetectionStatus",
"cloudformation:ListExports",
"cloudformation:ListStacks",
"cloudformation:ListImports",
"lambda:ListFunctions",
"iam:ListRoles",
"lambda:GetAccountSettings",
"ec2:DescribeSecurityGroups",
"cloudformation:EstimateTemplateCost",
"ec2:DescribeVpcs",
"lambda:ListEventSourceMappings",
"cloudformation:DescribeAccountLimits",
"ec2:DescribeSubnets",
"cloudformation:CreateStackSet",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/aws-serverless-repository-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:111122223333:stack/serverlessrepo-MyCFStackPrefix*/*",
"arn:aws:cloudformation:*:*:transform/Serverless-*",
"arn:aws:cloudformation:*:111122223333:stackset/aws-serverless-repository-MyCFStackPrefix*:*",
"arn:aws:cloudformation:*:111122223333:stackset/serverlessrepo-MyCFStackPrefix*:*"
]
},
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": "serverlessrepo:*",
"Resource": "arn:aws:serverlessrepo:*:*:applications/*"
},
{
"Sid": "ECR",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:*:*:repository/*"
}
]
}
```
**Explicação de permissões**
| Ações permitidas | Explicação |
| --- | --- |
| "lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"lambda:GetFunctionConfiguration",
"lambda:PutFunctionConcurrency",
"lambda:ListTags",
"lambda:DeleteFunction",
"lambda:GetAlias",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ListAliases",
"lambda:UpdateFunctionConfiguration",
"lambda:UpdateFunctionCode",
"lambda:AddPermission",
"lambda:DeleteFunctionConcurrency",
"lambda:RemovePermission",
"lambda:GetPolicy"
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListEventSourceMappings",
| Permita a criação e gerenciamento de funções do Lambda listadas como recursos. No exemplo, um prefixo de nome foi usado no identificador do recurso `arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*`, em que *MyAthenaLambdaFunctionsPrefix* é um prefixo compartilhado usado no nome do grupo de funções do Lambda de modo que elas não tenham de ser especificadas individualmente como recursos. É possível especificar um ou mais recursos de função do Lambda. |
| "s3:GetObject"
| Permite a leitura de um bucket de que o AWS Serverless Application Repository precisa conforme especificado pelo identificador de recurso arn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/\$1. |
| "cloudformation:*"
| Permite a criação e o gerenciamento de pilhas especificadas do CloudFormation pelo recurso *MyCFStackPrefix*. Essas pilhas e conjuntos de pilhas são como o AWS Serverless Application Repository implanta conectores e UDFs. |
| "serverlessrepo:*"
| Permite pesquisar, exibir, publicar e atualizar aplicativos no AWS Serverless Application Repository, especificados pelo identificador de recurso arn:aws:serverlessrepo:\$1:\$1:applications/\$1. |
# Permitir acesso a ML com o Athena
Os principais do IAM que executam consultas de ML do Athena devem ter permissão para executar a ação `sagemaker:invokeEndpoint` para os endpoints do SageMaker que eles usam. Inclua uma instrução de política semelhante à seguinte em políticas de permissões baseadas em identidade anexadas a identidades de usuário. Além disso, anexe [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy), que concede acesso completo às ações do Athena, ou uma política em linha modificada que permita um subconjunto de ações.
Substitua `arn:aws:sagemaker:region:AWSAcctID:ModelEndpoint` no exemplo pelo ARN ou ARNs de endpoints do modelo a serem usados em consultas. Para obter mais informações, consulte [Actions, resources, and condition keys for SageMaker AI](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonsagemaker.html) na *Referência de autorização do serviço*.
```
{
"Effect": "Allow",
"Action": [
"sagemaker:invokeEndpoint"
],
"Resource": "arn:aws:sagemaker:us-west-2:123456789012:workteam/public-crowd/default"
}
```
Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
# Habilitar o acesso federado à API do Athena
Esta seção aborda o acesso federado que permite que um usuário ou aplicação cliente na sua organização chame operações de API do Amazon Athena. Nesse caso, os usuários da sua organização não têm acesso direto ao Athena. Em vez disso, você gerencia as credenciais do usuário fora da AWS no Microsoft Active Directory. O Active Directory é compatível com [SAML 2.0](https://wiki.oasis-open.org/security) (Security Assertion Markup Language 2.0).
Para autenticar usuários nesse cenário, use o driver JDBC ou ODBC com suporte a SAML.2.0 para acessar o Active Directory Federation Services (ADFS) 3.0 e permitir que uma aplicação cliente chame as operações de API do Athena.
Para obter mais informações sobre o suporte ao SAML 2.0 na AWS, consulte [Sobre a federação baseada em SAML 2.0](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) no *Guia do usuário do IAM*.
**nota**
O acesso federado à API do Athena é permitido para um determinado tipo de provedor de identidade (IdP), o Active Directory Federation Service (ADFS 3.0), que faz parte do Windows Server. O acesso federado não é compatível com o recurso de propagação de identidade confiável do Centro de Identidade do IAM. O acesso é estabelecido por meio das versões dos drivers JDBC ou ODBC que oferecem suporte ao SAML 2.0. Para obter informações, consulte [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md) e [Conectar ao Amazon Athena com ODBC](connect-with-odbc.md).
**Topics**
+ [
## Antes de começar
](#access-federation-before-you-begin)
+ [
## Entender o processo de autenticação
](#access-federation-diagram)
+ [
## Procedimento: habilitar acesso federado baseado em SAML à API do Athena
](#access-federation-procedure)
## Antes de começar
Antes de começar, conclua os seguintes pré-requisitos:
+ Dentro da sua organização, instale e configure o ADFS 3.0 como seu IdP.
+ Instale e configure as versões mais recentes disponíveis dos drivers JDBC ou ODBC nos clientes usados para acessar o Athena. O driver deve incluir suporte para acesso federado compatível com o SAML 2.0. Para obter informações, consulte [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md) e [Conectar ao Amazon Athena com ODBC](connect-with-odbc.md).
## Entender o processo de autenticação
O diagrama a seguir ilustra o processo de autenticação do acesso federado à API do Athena.
![\[O diagrama de acesso federado à API do Athena.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/athena-saml-based-federation.png)
1. Um usuário na sua organização usa um aplicativo cliente com o driver JDBC ou ODBC para solicitar a autenticação do IdP da sua organização. O IdP é ADFS 3.0.
1. O IdP autentica o usuário no Active Directory, ou seja, o armazenamento de identidades da sua organização.
1. O IdP cria uma declaração do SAML com informações sobre o usuário e a envia para o aplicativo cliente por meio do driver JDBC ou ODBC.
1. O driver JDBC ODBC chama a operação da API AWS Security Token Service [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) e passa os seguintes parâmetros:
+ O ARN do provedor SAML
+ O ARN da função a ser assumida
+ A declaração do SAML do IdP
Para obter mais informações, consulte [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) na *Referência de API do AWS Security Token Service*.
1. A resposta da API para o aplicativo cliente por meio do driver JDBC ou ODBC inclui credenciais de segurança temporárias.
1. A aplicação cliente usa as credenciais de segurança temporárias para chamar as operações de API do Athena, permitindo que seus usuários acessem as operações de API do Athena.
## Procedimento: habilitar acesso federado baseado em SAML à API do Athena
Esse procedimento estabelece uma confiança entre o IdP da sua organização e sua conta da AWS para permitir acesso federado baseado em SAML à operação de API do Amazon Athena.
**Para habilitar o acesso federado à API do Athena:**
1. Em sua organização, registre a AWS como um provedor de serviços (SP) em seu IdP. Esse processo é conhecido como *confiança da parte dependente*. Para obter mais informações, consulte [Configuração do IdP SAML 2.0 com objeto de confiança de terceira parte confiável](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html) no *Guia do usuário do IAM*. Como parte dessa tarefa, execute estas etapas:
1. Obtenha o documento de metadados do SAML de amostra deste URL: [https://signin.aws.amazon.com/static/saml-metadata.xml](https://signin.aws.amazon.com/static/saml-metadata.xml).
1. No IdP da sua organização (ADFS), gere um arquivo XML de metadados equivalente que descreva o seu IdP como um provedor de identidade para a AWS. O arquivo de metadados deve incluir o nome do emissor, uma data de criação, uma data de expiração e chaves que a AWS usa para validar as respostas de autenticação (declarações) da sua organização.
1. No console do IAM, crie uma entidade de provedor de identidade do SAML. Para obter mais informações, consulte [Criação de provedores de identidade SAML do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html) no *Guia do usuário do IAM*. Como parte dessa etapa, realize as seguintes ações:
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Faça upload do documento de metadados SAML produzido pelo IdP (ADFS) na Etapa 1 deste procedimento.
1. No console do IAM, crie uma ou mais funções do IAM para seu IdP. Para obter mais informações, consulte [Criar uma função para um provedor de identidade de terceiros (federação)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do usuário do IAM*. Como parte dessa etapa, realize as seguintes ações:
+ Na política de permissões da função, estabeleça o que os usuários da sua organização têm permissão para fazer na AWS.
+ Na política de confiança da função, defina como principal a entidade do provedor do SAML que você criou na Etapa 2 deste procedimento.
Isso estabelece uma relação de confiança entre sua organização e a AWS.
1. No IdP da sua organização (ADFS), defina declarações que mapeiam usuários ou grupos na sua organização para as funções do IAM. O mapeamento de usuários e grupos para as funções do IAM também é conhecido como *regra de declaração*. Observe que usuários e grupos diferentes na sua organização podem ser mapeados para funções do IAM distintas.
Para obter informações sobre como configurar o mapeamento no ADFS, consulte a publicação do blog: [Habilitação de federação na AWS usando Windows Active Directory, ADFS e SAML 2.0](https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/).
1. Instale e configure o driver JDBC ou ODBC com o suporte a SAML 2.0. Para obter informações, consulte [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md) e [Conectar ao Amazon Athena com ODBC](connect-with-odbc.md).
1. Especifique a string de conexão do seu aplicativo para o driver JDBC ou ODBC. Para obter informações sobre a string de conexão que sua aplicação deve usar, consulte o tópico *“Using the Active Directory Federation Services (ADFS) Credentials Provider”* no *Guia de instalação e configuração do driver JDBC*, ou um tópico similar no *Guia de instalação e configuração do driver ODBC*, disponíveis para download em PDF nos tópicos [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md) e [Conectar ao Amazon Athena com ODBC](connect-with-odbc.md).
A seguir, veja um resumo de alto nível de como configurar a string de conexão para os drivers:
1. Em `AwsCredentialsProviderClass configuration`, defina o `com.simba.athena.iamsupport.plugin.AdfsCredentialsProvider` para indicar que você deseja usar a autenticação baseada em SAML 2.0 por meio do IdP do ADFS.
1. Em `idp_host`, forneça o nome de host do servidor do IdP do ADFS.
1. Em `idp_port`, informe o número da porta que o IdP do ADFS identifica a solicitação de declaração do SAML.
1. Em `UID` e `PWD`, forneça as credenciais de usuário do domínio do AD. Ao usar o driver no Windows, se `UID` e `PWD` não forem fornecidos, o driver tentará obter as credenciais de usuário do usuário conectado no computador com Windows.
1. Opcionalmente, defina `ssl_insecure` para `true`. Nesse caso, o driver não verifica a autenticidade do certificado SSL para o servidor do IdP do ADFS. Será necessário definir essa opção como `true` se o certificado SSL do IdP do ADFS não tiver sido configurado como confiável pelo driver.
1. Para habilitar o mapeamento de um usuário ou grupo de domínio do Active Directory para uma ou mais funções do IAM (como mencionado na etapa 4 deste procedimento), em `preferred_role`, na conexão do JDBC ou do ODBC, especifique a função do IAM (ARN) a ser assumida. Especificar o `preferred_role` é opcional. Ele é útil se a função não for a primeira a ser listada na regra de declaração.
As seguintes ações ocorrem como resultado desse procedimento:
1. O driver JDBC ou ODBC chama a API AWS STS [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) e transmite as declarações, conforme mostrado na etapa 4 do [diagrama de arquitetura](#access-federation-diagram).
1. AWSA certifica-se de que a solicitação para assumir a função vem do IdP referenciado na entidade do provedor do SAML.
1. Se a solicitação for bem-sucedida, a operação da API [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) do AWS STS retornará um conjunto de credenciais de segurança temporárias, que a aplicação cliente usa para fazer solicitações assinadas ao Athena.
Sua aplicação agora tem informações sobre o usuário atual e pode acessar o Athena de forma programática.
# Registrar em log e monitorar o Athena
Para detectar incidentes, receber alertas quando há incidentes e responder a eles, use estas opções com o Amazon Athena:
+ **Monitorar o Athena com AWS CloudTrail**: o [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) oferece um registro das ações executadas por um usuário, uma função ou um AWS service (Serviço da AWS) no Athena. Ele captura as chamadas do console do Athena e as chamadas de código para as operações de API do Athena como eventos. Dessa forma, você pode determinar a solicitação feita ao Athena, o endereço IP do qual a solicitação foi feita, quem fez a solicitação, quando ela foi feita e outros detalhes. Para obter mais informações, consulte [Registrar em log as chamadas de API do Amazon Athena com o AWS CloudTrail](monitor-with-cloudtrail.md).
Você também pode usar o Athena para consultar os arquivos de log do CloudTrail para o Athena e também para outros Serviços da AWS. Para obter mais informações, consulte [Consultar logs do AWS CloudTrail](cloudtrail-logs.md).
+ **Monitorar o uso do Athena com o CloudTrail e o Amazon Quick**: o [Amazon Quick](https://aws.amazon.com/quicksight/) é um serviço de business intelligence totalmente gerenciado e com tecnologia de nuvem que permite criar painéis interativos que sua organização pode acessar de qualquer dispositivo. Para obter um exemplo de solução que usa o CloudTrail e o Amazon Quick para monitorar o uso do Athena, consulte a postagem no blog AWS Big Data: [How Realtor.com monitors Amazon Athena usage with AWS CloudTrail and Quick](https://aws.amazon.com/blogs/big-data/analyzing-amazon-athena-usage-by-teams-within-a-real-estate-company/).
+ **Usar o Amazon EventBridge com o Athena**: a Amazon EventBridge oferece uma transmissão quase em tempo real dos eventos do sistema que descrevem as alterações nos recursos da AWS. O EventBridge reconhece essas alterações operacionais logo que acontecem, responde a elas e executa a ação corretiva conforme necessário, enviando mensagens para responder ao ambiente, ativando funções, fazendo alterações e capturando informações de estado. Os eventos são emitidos com base no melhor esforço. Para obter mais informações, consulte [Começar a usar o Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) no *Manual do usuário do Amazon EventBridge*.
+ **Usar grupos de trabalho para separar usuários, equipes, aplicações ou workloads, definir os limites e controlar os custos de consulta**: você pode exibir as métricas relacionadas à consulta no Amazon CloudWatch, controlar os custos de consulta com a configuração de limites para a quantidade de dados verificados, criar limites e acionar ações, como alarmes do Amazon SNS, quando esses limites são violados. Para obter mais informações, consulte [Usar grupos de trabalho para controlar o acesso a consultas e os custos](workgroups-manage-queries-control-costs.md). Use as permissões do IAM no nível do recurso para controlar o acesso a um determinado grupo de trabalho. Para obter mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md) e [Usar o CloudWatch e o EventBridge para monitorar as consultas e controlar os custos](workgroups-control-limits.md).
**Topics**
+ [
# Registrar em log as chamadas de API do Amazon Athena com o AWS CloudTrail
](monitor-with-cloudtrail.md)
# Registrar em log as chamadas de API do Amazon Athena com o AWS CloudTrail
O Athena é integrado ao AWS CloudTrail, um serviço que fornece um registro das ações realizadas por um usuário, uma função ou um AWS service (Serviço da AWS) no Athena.
O CloudTrail captura todas as chamadas de API para o Athena como eventos. As chamadas capturadas incluem as chamadas do console do Athena e as chamadas de código para as operações de API do Athena. Se você criar uma trilha, poderá habilitar a entrega contínua de eventos do CloudTrail para um bucket do Amazon S3, incluindo os eventos do Athena. Se você não configurar uma trilha, ainda poderá visualizar os eventos mais recentes no console do CloudTrail no **Histórico de eventos**.
Usando as informações coletadas pelo CloudTrail, é possível determinar a solicitação feita para o Athena, o endereço IP do qual a solicitação foi feita, quem fez a solicitação, quando ela foi feita e outros detalhes.
Para saber mais sobre o CloudTrail, consulte o [Guia do usuário do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
Você pode usar o Athena para consultar arquivos de log do CloudTrail do próprio Athena e de outros Serviços da AWS. Para obter mais informações, consulte [Consultar logs do AWS CloudTrail](cloudtrail-logs.md), [Hive JSON SerDe](hive-json-serde.md) e a publicação no blog de big data da AWS: [Usar as instruções CTAS com o Amazon Athena para reduzir custos e melhorar a performance](https://aws.amazon.com/blogs/big-data/using-ctas-statements-with-amazon-athena-to-reduce-cost-and-improve-performance/) (em inglês), que usa o CloudTrail para fornecer insights sobre o uso do Athena.
## Informações sobre o Athena no CloudTrail
O CloudTrail é habilitado em sua conta da Amazon Web Services quando ela é criada. Quando ocorre uma atividade no Athena, ela é registrada em um evento do CloudTrail com outros eventos de serviços da AWS no **Event history** (Histórico de eventos). Você pode visualizar, pesquisar e baixar os eventos recentes em sua conta da Amazon Web Services. Para saber mais, consulte [Viewing events with CloudTrail event history](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Para obter um registro contínuo dos eventos na sua conta da Amazon Web Services, incluindo os eventos do Athena, crie uma trilha. Uma *trilha* permite que o CloudTrail entregue arquivos de log a um bucket do Amazon S3. Por padrão, quando você cria uma trilha no console, ela é aplicada a todas as Regiões da AWS. A trilha loga eventos de todas as Regiões na partição da AWS e entrega os arquivos de log para o bucket do Amazon S3 especificado por você. Além disso, você pode configurar outros Serviços da AWS para analisar melhor e agir com base nos dados de eventos coletados nos logs do CloudTrail. Para obter mais informações, consulte as informações a seguir.
+ [Visão geral da criação de uma trilha](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [Serviços e integrações compatíveis com o CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configuração notificações do Amazon SNS para o CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Receber arquivos de log do CloudTrail de várias regiões](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [Receber arquivos de log do CloudTrail de várias contas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Todas as ações do Athena são registradas pelo CloudTrail e documentadas na [Referência de API do Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/). Por exemplo, as chamadas às ações [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html) e [GetQueryResults](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html) geram entradas nos arquivos de log do CloudTrail.
Cada entrada de log ou evento contém informações sobre quem gerou a solicitação. As informações de identidade ajudam a determinar:
+ Se a solicitação foi feita com credenciais de usuário-raiz ou usuário do AWS Identity and Access Management (IAM).
+ Se a solicitação foi feita com credenciais de segurança temporárias de um perfil ou de um usuário federado.
+ Se a solicitação foi feita por outro AWS service (Serviço da AWS).
Para saber mais, consulte [Elemento userIdentity do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Entender as entradas de arquivo de log do Athena
Uma trilha é uma configuração que permite a entrega de eventos como arquivos de log a um bucket Amazon S3 especificado. Os arquivos de log do CloudTrail contêm uma ou mais entradas de log. Um evento representa uma única solicitação de qualquer fonte, e inclui informações sobre a ação solicitada, data e hora da ação, parâmetros da solicitação e assim por diante. Os arquivos de log do CloudTrail não são um rastreamento de pilha ordenada de chamadas de API pública, portanto, não são exibidos em uma ordem específica.
**nota**
Para evitar a divulgação não intencional de informações sensíveis, a entrada `queryString` nos logs `StartQueryExecution` e `CreateNamedQuery` tem um valor de `***OMITTED***`. Isso faz parte do design. Para acessar a string de consulta real, você pode usar a API [GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html) do Athena e transmitir o valor de `responseElements.queryExecutionId` do log do CloudTrail.
Os seguintes exemplos demonstram entradas de log do CloudTrail para:
+ [StartQueryExecution (bem-sucedido)](#startqueryexecution-successful)
+ [StartQueryExecution (falha)](#startqueryexecution-failed)
+ [CreateNamedQuery](#createnamedquery)
### StartQueryExecution (êxito)
```
{
"eventVersion":"1.05",
"userIdentity":{
"type":"IAMUser",
"principalId":"EXAMPLE_PRINCIPAL_ID",
"arn":"arn:aws:iam::123456789012:user/johndoe",
"accountId":"123456789012",
"accessKeyId":"EXAMPLE_KEY_ID",
"userName":"johndoe"
},
"eventTime":"2017-05-04T00:23:55Z",
"eventSource":"athena.amazonaws.com",
"eventName":"StartQueryExecution",
"awsRegion":"us-east-1",
"sourceIPAddress":"77.88.999.69",
"userAgent":"aws-internal/3",
"requestParameters":{
"clientRequestToken":"16bc6e70-f972-4260-b18a-db1b623cb35c",
"resultConfiguration":{
"outputLocation":"s3://amzn-s3-demo-bucket/test/"
},
"queryString":"***OMITTED***"
},
"responseElements":{
"queryExecutionId":"b621c254-74e0-48e3-9630-78ed857782f9"
},
"requestID":"f5039b01-305f-11e7-b146-c3fc56a7dc7a",
"eventID":"c97cf8c8-6112-467a-8777-53bb38f83fd5",
"eventType":"AwsApiCall",
"recipientAccountId":"123456789012"
}
```
### StartQueryExecution (falha)
```
{
"eventVersion":"1.05",
"userIdentity":{
"type":"IAMUser",
"principalId":"EXAMPLE_PRINCIPAL_ID",
"arn":"arn:aws:iam::123456789012:user/johndoe",
"accountId":"123456789012",
"accessKeyId":"EXAMPLE_KEY_ID",
"userName":"johndoe"
},
"eventTime":"2017-05-04T00:21:57Z",
"eventSource":"athena.amazonaws.com",
"eventName":"StartQueryExecution",
"awsRegion":"us-east-1",
"sourceIPAddress":"77.88.999.69",
"userAgent":"aws-internal/3",
"errorCode":"InvalidRequestException",
"errorMessage":"Invalid result configuration. Should specify either output location or result configuration",
"requestParameters":{
"clientRequestToken":"ca0e965f-d6d8-4277-8257-814a57f57446",
"queryString":"***OMITTED***"
},
"responseElements":null,
"requestID":"aefbc057-305f-11e7-9f39-bbc56d5d161e",
"eventID":"6e1fc69b-d076-477e-8dec-024ee51488c4",
"eventType":"AwsApiCall",
"recipientAccountId":"123456789012"
}
```
### CreateNamedQuery
```
{
"eventVersion":"1.05",
"userIdentity":{
"type":"IAMUser",
"principalId":"EXAMPLE_PRINCIPAL_ID",
"arn":"arn:aws:iam::123456789012:user/johndoe",
"accountId":"123456789012",
"accessKeyId":"EXAMPLE_KEY_ID",
"userName":"johndoe"
},
"eventTime":"2017-05-16T22:00:58Z",
"eventSource":"athena.amazonaws.com",
"eventName":"CreateNamedQuery",
"awsRegion":"us-west-2",
"sourceIPAddress":"77.88.999.69",
"userAgent":"aws-cli/1.11.85 Python/2.7.10 Darwin/16.6.0 botocore/1.5.48",
"requestParameters":{
"name":"johndoetest",
"queryString":"***OMITTED***",
"database":"default",
"clientRequestToken":"fc1ad880-69ee-4df0-bb0f-1770d9a539b1"
},
"responseElements":{
"namedQueryId":"cdd0fe29-4787-4263-9188-a9c8db29f2d6"
},
"requestID":"2487dd96-3a83-11e7-8f67-c9de5ac76512",
"eventID":"15e3d3b5-6c3b-4c7c-bc0b-36a8dd95227b",
"eventType":"AwsApiCall",
"recipientAccountId":"123456789012"
},
```
# Validação de conformidade
Auditores de terceiros avaliam a segurança e a conformidade como parte de vários programas de conformidade da AWS. Isso inclui SOC, PCI, FedRAMP e outros.
Para obter uma lista dos Serviços da AWS no escopo de programas de conformidade específicos, consulte [Serviços da AWS no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/). Para obter informações gerais, consulte [Programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/).
É possível baixar relatórios de auditoria de terceiros usando o AWS Artifact. Para obter mais informações, consulte [Baixar os relatórios no AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Sua responsabilidade de conformidade durante o uso é determinada pela confidencialidade dos seus dados, pelos objetivos de conformidade da sua empresa e pelos regulamentos e leis aplicáveis. A AWS fornece os recursos a seguir para ajudar com a conformidade:
+ [Guias de início rápido de segurança e conformidade](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance): esses guias de implantação abordam as considerações de arquitetura e fornecem etapas para a implantação de ambientes de linha de base concentrados em compatibilidade e segurança na AWS.
+ [Arquitetura para segurança e conformidade com HIPAA na Amazon Web Services](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/architecting-hipaa-security-and-compliance-on-aws.html): este whitepaper descreve como as empresas podem usar a AWS para criar aplicações em conformidade com os padrões HIPAA.
+ [Recursos de compatibilidade da AWS](https://aws.amazon.com/compliance/resources/): essa coleção de manuais e guias pode ser aplicável a seu setor e local.
+ [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html): esse AWS service (Serviço da AWS) avalia até que ponto suas configurações de recursos atendem adequadamente às práticas internas e às diretrizes e regulamentações do setor.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html): esse AWS service (Serviço da AWS) fornece uma visão abrangente do estado de sua segurança na AWS que ajuda você a conferir sua conformidade com padrões e práticas recomendadas de segurança do setor.
# Resiliência no Athena
A infraestrutura global da AWS se baseia em Regiões da AWS e zonas de disponibilidade. A Regiões da AWS oferece várias zonas de disponibilidade separadas e isoladas fisicamente que são conectadas com baixa latência, altas taxas de throughput e em redes altamente redundantes. Com as Zonas de Disponibilidade, é possível projetar e operar aplicações e bancos de dados que executem o failover automaticamente entre as Zonas de Disponibilidade sem interrupção. As zonas de disponibilidade são mais altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
Para obter mais informações sobre Regiões da AWS e zonas de disponibilidade, consulte [Infraestrutura global da AWS](https://aws.amazon.com/about-aws/global-infrastructure/).
Além da infraestrutura global da AWS, oferecemos vários atributos para ajudar a oferecer suporte às suas necessidades de resiliência de dados e backup.
O Athena é sem servidor e, portanto, não há infraestrutura para configurar ou gerenciar. O Athena é altamente disponível e executa consultas usando recursos de computação em várias zonas de disponibilidade, encaminhando as consultas de forma automática e adequada se uma zona de disponibilidade específica estiver inacessível. O Athena usa o Amazon S3 como seu armazenamento de dados subjacente, o que torna os dados altamente disponíveis e duráveis. O Amazon S3 dispõe de uma infraestrutura durável para armazenar dados importantes e foi criado para oferecer durabilidade dos objetos de 99,999999999%. Seus dados são armazenados com redundância em várias instalações e diversos dispositivos em cada instalação.
# Segurança da infraestrutura no Athena
Por ser um serviço gerenciado, é protegido pela segurança da rede global da AWS. Para saber mais sobre serviços de segurança da AWS e como a AWS protege a infraestrutura, consulte [Segurança na Nuvem AWS](https://aws.amazon.com/security/). Para projetar seu ambiente da AWS usando as práticas recomendadas de segurança da infraestrutura, consulte [Proteção de Infraestrutura](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) em *Pilar de Segurança: AWS Well‐Architected Framework*.
Você usa chamadas de API publicadas pela AWS para acessar por meio da rede. Os clientes devem oferecer compatibilidade com:
+ Transport Layer Security (TLS). Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Conjuntos de criptografia com perfect forward secrecy (PFS) como DHE (Ephemeral Diffie-Hellman) ou ECDHE (Ephemeral Elliptic Curve Diffie-Hellman). A maioria dos sistemas modernos, como Java 7 e versões posteriores, comporta esses modos.
Use as políticas do IAM para restringir o acesso às operações do Athena. Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Manual do usuário do IAM*.
As [políticas gerenciadas](security-iam-awsmanpol.md) do Athena são fáceis de usar e atualizadas automaticamente com as ações necessárias de acordo com o desenvolvimento do serviço. As políticas em linha e gerenciadas pelo cliente podem ser ajustadas especificando nelas ações mais granulares do Athena. Conceda o acesso adequado ao local dos dados do Amazon S3. Para obter informações detalhadas e conhecer cenários para a concessão de acesso ao Amazon S3, consulte [Demonstrações de exemplo: gerenciar o acesso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access.html) no *Guia do desenvolvedor do Amazon Simple Storage Service*. Para obter mais informações e um exemplo das ações do Amazon S3 que devem ser permitidas, consulte o exemplo de política de bucket em [Acesso entre contas](cross-account-permissions.md).
**Topics**
+ [
# Conectar-se ao Amazon Athena usando um endpoint da VPC de interface
](interface-vpc-endpoint.md)
# Conectar-se ao Amazon Athena usando um endpoint da VPC de interface
Você pode melhorar a postura de segurança da sua VPC usando um [endpoint da VPC de interface (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) e um [endpoint da VPC do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/vpc-endpoint.html) em sua nuvem privada virtual (VPC). Um endpoint da VPC de interface melhora a segurança ao oferecer controle sobre quais destinos podem ser alcançados de dentro da sua VPC. Cada endpoint da VPC é representado por uma ou mais [interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) (ENIs) com endereços IP privados nas sub-redes da VPC.
O endpoint da VPC de interface conecta sua VPC diretamente ao Athena sem um gateway da Internet, um dispositivo NAT, uma conexão VPN ou uma conexão Direct Connect. Não é necessário que as instâncias na sua VPC tenham endereços IP públicos para se comunicarem com a API do Athena.
Para usar o Athena por meio da VPC, você deve se conectar de uma instância que esteja dentro da VPC ou conectar sua rede privada à VPC usando o Amazon Virtual Private Network (VPN) ou uma Direct Connect. Para obter informações sobre o Amazon VPN, consulte [Conexões VPN](https://docs.aws.amazon.com/vpc/latest/userguide/vpn-connections.html) no *Guia do usuário do Amazon Virtual Private Cloud*. Para obter informações sobre o AWS Direct Connect, consulte [Creating a connection](https://docs.aws.amazon.com/directconnect/latest/UserGuide/create-connection.html) (Criação de uma conexão) no *Guia do usuário do Direct Connect*.
O Athena aceita endpoints da VPC em todas as Regiões da AWS onde o [Amazon VPC](https://docs.aws.amazon.com/general/latest/gr/rande.html#vpc_region) e o [Athena](https://docs.aws.amazon.com/general/latest/gr/rande.html#athena) estão disponíveis.
É possível criar um endpoint da VPC de interface para se conectar ao Athena usando os comandos do Console de gerenciamento da AWS ou da AWS Command Line Interface (AWS CLI). Para obter mais informações, consulte [Creating an interface endpoint](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) (Criação de um endpoint de interface).
Depois de criar um endpoint da VPC de interface, se você habilitar nomes de host [DNS privados](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#vpce-private-dns) para o endpoint, o endpoint padrão do Athena (https://athena.*Region*.amazonaws.com) será resolvido para seu endpoint da VPC.
Se você não habilitar nomes de host DNS privados, o Amazon VPC fornecerá um nome de endpoint DNS que poderá ser usado no seguinte formato:
```
VPC_Endpoint_ID.athena.Region.vpce.amazonaws.com
```
Para mais informações, consulte [VPC endpoints de interface (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) no *Guia do usuário da Amazon VPC*.
O Athena permite fazer chamadas para todas as [ações de API](https://docs.aws.amazon.com/athena/latest/APIReference/API_Operations.html) na sua VPC.
## Criar uma política de endpoint da VPC para o Athena
Você pode criar uma política de endpoints da Amazon VPC para o Athena para especificar restrições como:
+ **Entidade principal**: a entidade principal que pode executar ações.
+ **Ações**: as ações que podem ser executadas.
+ **Recursos**: os recursos sobre os quais as ações podem ser realizadas.
+ **Somente identidades confiáveis**: use a condição `aws:PrincipalOrgId` para restringir o acesso somente às credenciais que fazem parte de sua organização da AWS. Isso pode ajudar a impedir o acesso de entidades principais não intencionais.
+ **Somente recursos confiáveis**: use a condição `aws:ResourceOrgId` para impedir o acesso a recursos não intencionais.
+ **Somente identidades e recursos confiáveis**: crie uma política combinada para um endpoint da VPC que ajude a impedir o acesso a recursos e entidades principais não intencionais.
Para obter mais informações, consulte [Controlar acesso a serviços com endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) no *Guia do usuário da Amazon VPC* e no [Apêndice 2: exemplos de políticas de endpoints da VPC](https://docs.aws.amazon.com/whitepapers/latest/building-a-data-perimeter-on-aws/appendix-2-vpc-endpoint-policy-examples.html) no whitepaper da AWS *Criar um perímetro de dados na AWS*.
**Example Política de endpoint da VPC**
O exemplo a seguir permite solicitações de identidades de organizações para recursos de organizações, e permite solicitações de entidades principais de serviços da AWS.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRequestsByOrgsIdentitiesToOrgsResources",
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalOrgID": "my-org-id",
"aws:ResourceOrgID": "my-org-id"
}
}
},
{
"Sid": "AllowRequestsByAWSServicePrincipals",
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "*",
"Resource": "*",
"Condition": {
"Bool": {
"aws:PrincipalIsAWSService": "true"
}
}
}
]
}
```
Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
## Sobre os endpoints da VPC em sub-redes compartilhadas
Você não pode criar, descrever, modificar ou excluir endpoints da VPC em sub-redes que são compartilhadas com você. No entanto, é possível usar os endpoints da VPC em sub-redes que são compartilhadas com você. Para obter informações sobre o compartilhamento da VPC, consulte [Compartilhar sua VPC com outras contas](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-sharing.html) no *Guia do usuário da Amazon VPC*.
# Análise de vulnerabilidade e configuração no Athena
O Athena é sem servidor, portanto, não há infraestrutura para configurar ou gerenciar. A AWS processa as tarefas básicas de segurança, como aplicação de patches a bancos de dados e sistemas operacionais (SO) convidados, configuração de firewalls e recuperação de desastres. Esses procedimentos foram revisados e certificados por terceiros certificados. Para obter mais detalhes, consulte os seguintes recursos da AWS:
+ [Modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/)
+ [Práticas recomendadas de segurança, identidade e conformidade](https://aws.amazon.com/architecture/security-identity-compliance/)
# Usar o Athena para consultar dados registrados no AWS Lake Formation
O [AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html) permite definir e aplicar políticas de acesso no nível do banco de dados, tabela e coluna ao usar as consultas do Athena para ler os dados armazenados no Amazon S3 ou acessados por meio de fontes de dados federadas. O Lake Formation fornece uma camada de autorização e governança dos dados armazenados no Amazon S3 ou em catálogos de dados federados. É possível usar uma hierarquia de permissões no Lake Formation para conceder ou revogar permissões de leitura de objetos do catálogo de dados, como bancos de dados, tabelas e colunas. O Lake Formation simplifica o gerenciamento de permissões e permite implementar um Fine-Grained Access Control (FGAC – Controle de acesso refinado) para seus dados.
É possível usar o Athena para consultar os dados tanto registrados quanto não registrados no Lake Formation.
As permissões do Lake Formation são aplicadas ao usar o Athena para consultar dados da fonte de locais do Amazon S3 ou catálogos de dados registrados no Lake Formation. As permissões do Lake Formation também são aplicadas ao criar bancos de dados e tabelas que apontem para os locais de dados registrados do Amazon S3 ou catálogos de dados.
As permissões do Lake Formation não se aplicam à gravação de objetos nem à consulta de dados ou metadados que não estejam registrados no Lake Formation. Para dados da fonte e metadados que não estejam registrados no Lake Formation, o acesso será determinado por políticas de permissões do IAM para ações do AWS Glue. Os locais de resultados de consulta do Athena no Amazon S3 não podem ser registrados no Lake Formation, e as políticas de permissões do IAM no Amazon S3 controlam o acesso. Além disso, as permissões do Lake Formation não se aplicam ao histórico de consultas do Athena. É possível usar grupos de trabalho do Athena para controlar o acesso ao histórico de consultas.
Para obter mais informações sobre o Lake Formation, consulte [Perguntas Frequentes do Lake Formation](https://aws.amazon.com/lake-formation/faqs/) e o [Guia do desenvolvedor do AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html).
## Aplicar as permissões do Lake Formation aos bancos de dados e tabelas existentes
Se você for novo no Athena e usar o Lake Formation para configurar o acesso aos dados da consulta, não será necessário configurar políticas do IAM para que os usuários possam ler dados e criar metadados. É possível usar o Lake Formation para administrar permissões.
Registrar dados no Lake Formation e atualizar políticas de permissões do IAM não são requisitos. Se os dados não estiverem registrados no Lake Formation, os usuários do Athena com as devidas permissões poderão continuar consultando os dados não registrados no Lake Formation.
Se você tiver usuários existentes do Athena que consultem dados do Amazon S3 não registrados no Lake Formation, poderá atualizar as permissões do IAM para o Amazon S3 e o AWS Glue Data Catalog, se aplicável, de modo que você possa usar as permissões do Lake Formation para gerenciar o acesso dos usuários centralmente. Para obter permissão de leitura dos locais de dados do Amazon S3, é possível atualizar as políticas baseadas em recurso e em identidade para modificar as permissões do Amazon S3. Para obter acesso aos metadados, se você configurou políticas no nível do recurso para controle de acesso refinado com o AWS Glue, pode usar as permissões do Lake Formation para gerenciar o acesso.
Para obter mais informações, consulte [Configurar o acesso a bancos de dados e tabelas no AWS Glue Data Catalog](fine-grained-access-to-glue-resources.md) e [Atualização das permissões de dados do AWS Glue para o modelo do AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/upgrade-glue-lake-formation.html) no *Guia do desenvolvedor do AWS Lake Formation*.
**Topics**
+ [
## Aplicar as permissões do Lake Formation aos bancos de dados e tabelas existentes
](#lf-athena-apply-lf-permissions-to-existing-databases-and-tables)
+ [Como o acesso a dados funciona](lf-athena-access.md)
+ [Considerações e limitações](lf-athena-limitations.md)
+ [Acesso entre contas](lf-athena-limitations-cross-account.md)
+ [Gerenciamento de permissões de usuário](lf-athena-user-permissions.md)
+ [Usar o Lake Formation e o JDBC ou o ODBC para acesso federado](security-athena-lake-formation-jdbc.md)
# Como o Athena acessa os dados registrados no Lake Formation
O fluxo de trabalho de acesso descrito nesta seção é aplicável somente à execução de consultas do Athena em locais, catálogos de dados ou objetos de metadados do Amazon S3 registrados no Lake Formation. Para obter mais informações, consulte [Registering a data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html) (Registrar um data lake) no *Guia do desenvolvedor do AWS Lake Formation*. Além de registrar os dados, o administrador do Lake Formation aplica as permissões do Lake Formation que concedem ou revogam o acesso aos metadados no catálogo de dados, AWS Glue Data Catalog ou no local dos dados no Amazon S3. Para obter mais informações, consulte [Security and access control to metadata and data](https://docs.aws.amazon.com/lake-formation/latest/dg/security-data-access.html#security-data-access-permissions) (Controle de segurança e acesso a metadados e dados) no *Guia do desenvolvedor do AWS Lake Formation*.
Cada vez que uma entidade principal do Athena (usuário, grupo ou perfil) executar uma consulta em dados registrados usando o Lake Formation, o Lake Formation verificará se a entidade principal tem as devidas permissões do Lake Formation para o banco de dados, a tabela e a fonte de dados, conforme apropriado para a consulta. Se o principal tiver acesso, o Lake Formation *venderá* credenciais temporárias para o Athena e a consulta será executada.
O seguinte diagrama mostra o funcionamento da venda de credenciais no Athena por consulta em um exemplo de consulta `SELECT` em uma tabela com um local ou catálogos de dados do Amazon S3 registrado no Lake Formation:
![\[Fluxo de trabalho de venda de credenciais para uma consulta em uma tabela do Athena.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/lake-formation-athena-security.png)
1. Um principal executa a consulta `SELECT` no Athena.
1. O Athena analisa a consulta e verifica as permissões do Lake Formation para ver se o principal recebeu acesso à tabela e às suas colunas.
1. Se o principal tiver acesso, o Athena solicitará as credenciais do Lake Formation. Se o principal *não* tiver acesso, o Athena emitirá um erro de acesso negado.
1. O Lake Formation emite as credenciais ao Athena para usar na leitura dos dados do Amazon S3 ou catálogo, junto com a lista de colunas permitidas.
1. O Athena usa as credenciais temporárias do Lake Formation para consultar os dados do Amazon S3 ou catálogo. Após a conclusão da consulta, o Athena descarta as credenciais.
# Considerações e limitações da consulta a dados registrados no Lake Formation
Considere as questões a seguir ao usar o Athena para consultar dados registrados no Lake Formation. Para obter informações adicionais, consulte [Problemas conhecidos do AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/limitations.html) no *Guia do desenvolvedor do AWS Lake Formation*.
**Topics**
+ [Metadados de coluna visíveis para usuários sem permissões de dados para colunas em algumas circunstâncias](#lf-athena-limitations-column-metadata)
+ [Trabalhar com permissões do Lake Formation para visualizações](#lf-athena-limitations-permissions-to-views)
+ [
## Suporte ao DDL do Iceberg
](#lf-athena-limitations-iceberg-ddl-operations)
+ [
## Controle de acesso detalhado do Lake Formation e grupos de trabalho do Athena
](#lf-athena-limitations-fine-grained-access-control)
+ [Local dos resultados de consultas do Athena no Amazon S3 não registrado no Lake Formation](#lf-athena-limitations-query-results-location)
+ [Usar grupos de trabalho do Athena para limitar o acesso ao histórico de consultas](#lf-athena-limitations-use-workgroups-to-limit-access-to-query-history)
+ [O Amazon S3 com CSE-KMS registrado no Lake Formation não pode ser consultado no Athena](#lf-athena-limitations-cse-kms)
+ [Locais de dados particionados registrados no Lake Formation devem estar em subdiretórios de tabela](#lf-athena-limitations-partioned-data-locations)
+ [Consultas Create Table As Select (CTAS) exigem permissões de gravação do Amazon S3](#lf-athena-limitations-ctas-queries)
+ [
## A permissão DESCRIBE é necessária no banco de dados padrão
](#lf-athena-limitations-describe-default)
## Metadados de coluna visíveis para usuários não autorizados em algumas circunstâncias com Avro e SerDe personalizado
A autorização no nível da coluna do Lake Formation impede que os usuários acessem os dados nas colunas para as quais eles não tenham permissões do Lake Formation. No entanto, em determinadas situações, os usuários podem acessar metadados que descrevem todas as colunas na tabela, incluindo as colunas para as quais eles não têm permissões para os dados.
Isso ocorre quando os metadados da coluna são armazenados nas propriedades das tabelas usando o formato de armazenamento Apache Avro ou um serializador/desserializador (SerDe) personalizado no qual o esquema da tabela é definido nas propriedades da tabela juntamente com a definição do SerDe. Ao usar o Athena com o Lake Formation, recomendamos revisar o conteúdo das propriedades da tabela que você registrou no Lake Formation e, sempre que possível, limitar as informações armazenadas nas propriedades da tabela para impedir que metadados confidenciais fiquem visíveis aos usuários.
## Entender o Lake Formation e as visualizações
Para dados registrados no Lake Formation, um usuário do Athena poderá criar um `VIEW` somente se tiver permissões do Lake Formation para as tabelas, as colunas e os locais de dados de origem do Amazon S3 nos quais a `VIEW` se baseia. Depois que uma `VIEW` é criada no Athena, as permissões do Lake Formation podem ser aplicadas à `VIEW`. As permissões no nível da coluna não estão disponíveis para uma `VIEW`. Os usuários com permissões do Lake Formation para uma `VIEW`, mas sem permissões para a tabela e as colunas nas quais a visualização foi baseada, não podem usar a `VIEW` para consultar dados. No entanto, os usuários com essa combinação de permissões podem usar instruções como `DESCRIBE VIEW`, `SHOW CREATE VIEW` e `SHOW COLUMNS` para ver metadados `VIEW`. Por esse motivo, alinhe as permissões do Lake Formation a cada `VIEW` com as permissões subjacentes da tabela. Filtros de células definidos em uma tabela não se aplicam a um `VIEW` para essa tabela. Os nomes de links de recursos devem ter o mesmo nome que o recurso na conta de origem. Há limitações adicionais ao se trabalhar com visualizações em uma configuração entre contas. Para obter mais informações sobre como configurar permissões para visualizações compartilhadas entre contas, consulte [Configurar o acesso entre contas ao catálogo de dados](lf-athena-limitations-cross-account.md).
## Suporte ao DDL do Iceberg
Atualmente, o Athena não oferece suporte a operações de DDL em tabelas Iceberg cuja localização esteja registrada no Lake Formation. A tentativa de executar uma consulta DDL em uma dessas tabelas do Iceberg pode retornar um erro de acesso negado ao Amazon S3 ou falhar com o esgotamento do tempo limite da consulta. As operações de DDL nas tabelas do Iceberg exigem que o usuário tenha acesso direto do Amazon S3 à localização da tabela do Iceberg.
## Controle de acesso detalhado do Lake Formation e grupos de trabalho do Athena
Os usuários do mesmo grupo de trabalho do Athena podem visualizar os dados que o controle de acesso detalhado do Lake Formation configurou para serem acessíveis ao grupo de trabalho. Para obter mais informações sobre como usar o controle de acesso detalhado no Lake Formation, consulte [Gerenciar o controle de acesso detalhado usando o AWS Lake Formation](https://aws.amazon.com/blogs/big-data/manage-fine-grained-access-control-using-aws-lake-formation/) no *AWS Big Data Blog*.
## Local dos resultados de consultas do Athena no Amazon S3 não registrado no Lake Formation
O local dos resultados de consultas do Athena no Amazon S3 não pode ser registrado no Lake Formation. As permissões do Lake Formation não limitam o acesso a esses locais. A menos que você limite o acesso, os usuários do Athena podem acessar arquivos de resultados de consulta e metadados mesmo sem permissões do Lake Formation para os dados. Para evitar isso, recomendamos que você use grupos de trabalho para especificar o local dos resultados das consultas e alinhe a associação do grupo de trabalho com as permissões do Lake Formation. Depois disso, você pode usar as políticas de permissões do IAM para limitar o acesso aos locais de resultados de consultas. Para obter mais informações sobre resultados de consultas, veja [Trabalhar com resultados de consultas e consultas recentes](querying.md).
## Usar grupos de trabalho do Athena para limitar o acesso ao histórico de consultas
O histórico de consultas do Athena expõe uma lista de consultas salvas e strings de consulta completas. A menos que você use grupos de trabalho para separar o acesso a históricos de consultas, os usuários do Athena que não estão autorizados a consultar os dados no Lake Formation poderão visualizar as strings de consultas executadas nesses dados, incluindo nomes de coluna, critérios de seleção e etc. Recomendamos que você use grupos de trabalho para separar históricos de consultas e alinhar a associação do grupo de trabalho do Athena com as permissões do Lake Formation para limitar o acesso. Para obter mais informações, consulte [Usar grupos de trabalho para controlar o acesso a consultas e os custos](workgroups-manage-queries-control-costs.md).
## Consultar as tabelas criptografadas CSE\$1KMS registradas no Lake Formation
Tabelas em Open Table Format (OTF), como do Apache Iceberg, que têm as seguintes características, não podem ser consultadas com o Athena:
+ As tabelas são baseadas nos locais de dados do Amazon S3 que estão registrados no Lake Formation.
+ Os objetos no Amazon S3 são criptografados usando a criptografia do lado do cliente (CSE).
+ A criptografia usa chaves do AWS KMS gerenciadas pelo cliente (`CSE_KMS`).
Para consultar tabelas não OTF criptografadas com uma chave `CSE_KMS`, adicione o bloco a seguir à política da chave AWS KMS que você usa para criptografia CSE. ** indica o ARN da chave AWS KMS que criptografa os dados. ** indica o ARN do perfil do IAM que registra a localização do Amazon S3 no Lake Formation.
```
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "kms:Decrypt",
"Resource": "",
"Condition": {
"ArnLike": {
"aws:PrincipalArn": ""
}
}
}
```
## Locais de dados particionados registrados no Lake Formation devem estar em subdiretórios de tabela
As tabelas particionadas registradas no Lake Formation devem ter dados particionados em diretórios que são subdiretórios da tabela no Amazon S3. Por exemplo, uma tabela com o local `s3://amzn-s3-demo-bucket/mytable` e as partições `s3://amzn-s3-demo-bucket/mytable/dt=2019-07-11`, `s3://amzn-s3-demo-bucket/mytable/dt=2019-07-12` etc. pode ser registrada no Lake Formation e consultada com o Athena. Por outro lado, uma tabela com o local `s3://amzn-s3-demo-bucket/mytable` e as partições localizadas em `s3://amzn-s3-demo-bucket/dt=2019-07-11`, `s3://amzn-s3-demo-bucket/dt=2019-07-12` etc. não pode ser registrada no Lake Formation. Como essas partições não são subdiretórios de `s3://amzn-s3-demo-bucket/mytable`, elas também não podem ser lidas pelo Athena.
## Consultas Create Table As Select (CTAS) exigem permissões de gravação do Amazon S3
As Create Table As Statements (CTAS) exigem acesso de gravação ao local das tabelas do Amazon S3. Para executar consultas CTAS em dados registrados no Lake Formation, os usuários do Athena devem ter as permissões do IAM para gravar nos locais de tabela do Amazon S3 e as devidas permissões do Lake Formation para ler os locais de dados. Para obter mais informações, consulte [Criar uma tabela com base em resultados de consultas (CTAS)](ctas.md).
## A permissão DESCRIBE é necessária no banco de dados padrão
A permissão `DESCRIBE` do Lake Formation é necessária no banco de dados `default` para que o Lake Formation possa visualizá-lo. O comando da AWS CLI de exemplo a seguir concede a permissão `DESCRIBE` no banco de dados `default` ao usuário `datalake_user1` na conta da AWS `111122223333`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DESCRIBE" --resource '{ "Database": {"Name":"default"}}
```
Para obter mais informações, consulte [DESCRIBE](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html#perm-describe) no *Guia do desenvolvedor do AWS Lake Formation*.
# Configurar o acesso entre contas ao catálogo de dados
Para acessar um catálogo de dados em outra conta, você pode usar o recurso do AWS Glue entre contas do Athena ou configurar o acesso entre contas no Lake Formation.
## Opção A: configurar o acesso entre contas ao catálogo de dados no Athena
Você pode usar o recurso de catálogo do AWS Glue entre contas do Athena para registrar o catálogo em sua conta. Esse recurso está disponível somente no mecanismo Athena versão 2 e posteriores e está limitado ao uso entre contas na mesma região. Para obter mais informações, consulte [Registrar um catálogo de dados de outra conta](data-sources-glue-cross-account.md).
Se o catálogo de dados a ser compartilhado tiver uma política de recursos configurada no AWS Glue, ele deverá ser atualizado para permitir acesso ao AWS Resource Access Manager e conceder permissões à conta B para usar o catálogo de dados da conta A.
Para obter mais informações, consulte [Configurar o acesso entre contas aos catálogos de dados do AWS Glue](security-iam-cross-account-glue-catalog-access.md).
## Opção B: configurar o acesso entre contas no Lake Formation
AWS Lake FormationO permite que você use uma única conta para gerenciar um catálogo de dados central. Você pode usar esse recurso para implementar o [acesso entre contas](https://docs.aws.amazon.com/lake-formation/latest/dg/access-control-cross-account.html) a metadados do catálogo de dados e aos dados subjacentes. Por exemplo, uma conta de proprietário pode conceder à outra conta (destinatário) a permissão `SELECT` em uma tabela.
Para que um banco de dados ou uma tabela compartilhada apareça no editor de consultas do Athena, [crie um link de recurso](https://docs.aws.amazon.com/lake-formation/latest/dg/resource-links-about.html) no Lake Formation para o banco de dados ou a tabela compartilhada. Quando a conta de destinatário no Lake Formation consulta a tabela do proprietário, o [CloudTrail](https://docs.aws.amazon.com/lake-formation/latest/dg/cross-account-logging.html) adiciona o evento de acesso a dados aos logs das contas tanto de destinatário quanto de proprietário.
Para visualizações compartilhadas, lembre-se dos seguintes pontos:
+ As consultas são executadas nos links dos recursos de destino, não na visualização ou tabela de origem. Em seguida, a saída é compartilhada com a conta de destino.
+ Não basta compartilhar apenas a visualização. Todas as tabelas envolvidas na criação da visualização devem fazer parte do compartilhamento entre contas.
+ O nome do link do recurso criado nos recursos compartilhados deve corresponder ao nome do recurso na conta do proprietário. Se o nome não corresponder, será gerada uma mensagem de erro semelhante a Falha ao analisar a visualização armazenada 'awsdatacatalog.*my-lf-resource-link*.*my-lf-view*': line 3:3: O esquema *schema\$1name* não existe.
Para obter mais informações sobre o acesso entre contas no Lake Formation, consulte os seguintes recursos no *Guia do desenvolvedor do AWS Lake Formation*:
[Acesso entre contas](https://docs.aws.amazon.com/lake-formation/latest/dg/access-control-cross-account.html)
[How resource links work in Lake Formation (Como os links de recursos funcionam no Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/resource-links-about.html)
[Cross-account CloudTrail logging (Registro em log no CloudTrail entre contas](https://docs.aws.amazon.com/lake-formation/latest/dg/cross-account-logging.html)
# Gerenciar as permissões de usuário do Lake Formation e do Athena
O Lake Formation vende credenciais para consultar armazenamentos de dados ou catálogos federados do Amazon S3 que estão registrados no Lake Formation. Se você já tiver usado políticas do IAM para permitir ou negar permissões para ler catálogos ou locais de dados no Amazon S3, poderá usar as permissões do Lake Formation. No entanto, outras permissões do IAM ainda são necessárias.
Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Manual do usuário do IAM*.
As seções a seguir resumem as permissões necessárias para usar o Athena nas consultas de dados registrados no Lake Formation. Para obter mais informações, consulte [Segurança no AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/security.html) no *Guia do desenvolvedor do AWS Lake Formation*.
**Topics**
+ [
## Permissões baseadas em identidade para Lake Formation e Athena
](#lf-athena-user-permissions-identity-based)
+ [
## Permissões do Amazon S3 para locais de resultados de consultas do Athena
](#lf-athena-user-permissions-query-results-locations)
+ [
## Associações de grupos de trabalho do Athena para consultar o histórico
](#lf-athena-user-permissions-workgroup-memberships-query-history)
+ [
## Permissões do Lake Formation para dados
](#lf-athena-user-permissions-data)
+ [
## Permissões do IAM para gravar em locais do Amazon S3
](#lf-athena-user-permissions-s3-write)
+ [
## Permissões para dados criptografados, metadados e resultados de consultas do Athena
](#lf-athena-user-permissions-encrypted)
+ [
## Permissões baseadas em recursos para buckets do Amazon S3 em contas externas (opcional)
](#lf-athena-user-permissions-s3-cross-account)
## Permissões baseadas em identidade para Lake Formation e Athena
Qualquer pessoa que usa o Athena para consultar dados registrados no Lake Formation deve ter uma política de permissões do IAM que permita a ação `lakeformation:GetDataAccess`. O [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy) permite essa ação. Se você usar políticas em linha, atualize as políticas de permissões para permitir essa ação.
No Lake Formation, um *administrador de data lake* tem permissões para criar objetos de metadados, como bancos de dados e tabelas, conceder permissões do Lake Formation a outros usuários e registrar novos locais ou catálogos de dados do Amazon S3. Para registrar novos locais, são necessárias permissões para a função vinculada ao serviço no Lake Formation. Para obter mais informações, consulte [Create a data lake administrator](https://docs.aws.amazon.com/lake-formation/latest/dg/getting-started-setup.html#create-data-lake-admin) (Criar um administrador de data lake) e [Service-linked role permissions for Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/service-linked-roles.html#service-linked-role-permissions) (Permissões de função vinculada ao serviço no Lake Formation) no *Guia do desenvolvedor do AWS Lake Formation*.
Um usuário do Lake Formation pode usar o Athena para consultar bancos de dados, tabelas, colunas de tabelas e armazenamentos de dados ou catálogos subjacentes do Amazon S3 com base nas permissões do Lake Formation concedidas a ele pelos administradores de data lake. Os usuários não podem criar bancos de dados ou tabelas, nem registrar novos locais do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Create a data lake user](https://docs.aws.amazon.com/lake-formation/latest/dg/cloudtrail-tut-create-lf-user.html) (Criar um usuário do data lake) no *Guia do desenvolvedor do AWS Lake Formation*.
No Athena, as políticas de permissões baseadas em identidade, incluindo aquelas para grupos de trabalho do Athena, ainda controlam o acesso às ações do Athena para usuários de contas da Amazon Web Services. Além disso, o acesso federado pode ser concedido por meio da autenticação baseada em SAML disponível nos drivers do Athena. Para obter mais informações, consulte [Usar grupos de trabalho para controlar o acesso a consultas e os custos](workgroups-manage-queries-control-costs.md), [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md) e [Habilitar o acesso federado à API do Athena](access-federation-saml.md).
Para obter mais informações, consulte [Granting Lake Formation permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html) (Conceder permissões do Lake Formation) no *Guia do desenvolvedor do AWS Lake Formation*.
## Permissões do Amazon S3 para locais de resultados de consultas do Athena
O local dos resultados de consultas do Athena no Amazon S3 não pode ser registrado no Lake Formation. As permissões do Lake Formation não limitam o acesso a esses locais. A menos que você limite o acesso, os usuários do Athena podem acessar arquivos de resultados de consulta e metadados mesmo sem permissões do Lake Formation para os dados. Para evitar isso, recomendamos que você use grupos de trabalho para especificar o local dos resultados das consultas e alinhe a associação do grupo de trabalho com as permissões do Lake Formation. Depois disso, você pode usar as políticas de permissões do IAM para limitar o acesso aos locais de resultados de consultas. Para obter mais informações sobre resultados de consultas, veja [Trabalhar com resultados de consultas e consultas recentes](querying.md).
## Associações de grupos de trabalho do Athena para consultar o histórico
O histórico de consultas do Athena expõe uma lista de consultas salvas e strings de consulta completas. A menos que você use grupos de trabalho para separar o acesso a históricos de consultas, os usuários do Athena que não estão autorizados a consultar os dados no Lake Formation poderão visualizar as strings de consultas executadas nesses dados, incluindo nomes de coluna, critérios de seleção e etc. Recomendamos que você use grupos de trabalho para separar históricos de consultas e alinhar a associação do grupo de trabalho do Athena com as permissões do Lake Formation para limitar o acesso. Para obter mais informações, consulte [Usar grupos de trabalho para controlar o acesso a consultas e os custos](workgroups-manage-queries-control-costs.md).
## Permissões do Lake Formation para dados
Além da permissão de linha de base para usar o Lake Formation, os usuários do Athena devem ter permissões do Lake Formation para acessar os recursos que eles consultam. Essas permissões são concedidas e gerenciadas por um administrador do Lake Formation. Para obter mais informações, consulte [Security and access control to metadata and data](https://docs.aws.amazon.com/lake-formation/latest/dg/security-data-access.html#security-data-access-permissions) (Controle de segurança e acesso a metadados e dados) no *Guia do desenvolvedor do AWS Lake Formation*.
## Permissões do IAM para gravar em locais do Amazon S3
As permissões do Lake Formation para o Amazon S3 não incluem a capacidade de gravar no Amazon S3. As Create Table As Statements (CTAS) exigem acesso de gravação ao local das tabelas do Amazon S3. Para executar consultas CTAS em dados registrados no Lake Formation, os usuários do Athena devem ter as permissões do IAM para gravar nos locais de tabela do Amazon S3 e as devidas permissões do Lake Formation para ler os locais de dados. Para obter mais informações, consulte [Criar uma tabela com base em resultados de consultas (CTAS)](ctas.md).
## Permissões para dados criptografados, metadados e resultados de consultas do Athena
É possível criptografar dados da fonte subjacentes no Amazon S3 e metadados no catálogo que estejam registrados no Lake Formation. Não há alteração na maneira como o Athena processa a criptografia de resultados das consultas quando ele é usado para consultar dados registrados no Lake Formation. Para obter mais informações, consulte [Criptografar os resultados de consultas do Athena armazenados no Amazon S3](encrypting-query-results-stored-in-s3.md).
+ **Criptografia de dados de origem**: a criptografia dos dados de origem dos locais de dados do Amazon S3 é permitida. Os usuários do Athena que consultam locais criptografados do Amazon S3 registrados no Lake Formation precisam de permissões para criptografar e descriptografar dados. Para obter mais informações sobre os requisitos, consulte [Opções de criptografia permitidas do Amazon S3](encryption.md#encryption-options-S3-and-Athena) e [Permissões para dados criptografados no Amazon S3](encryption.md#permissions-for-encrypting-and-decrypting-data).
+ **Criptografia de metadados**: a criptografia de metadados no AWS Glue Data Catalog é compatível. Para os principais que usam o Athena, as políticas baseadas em identidade devem permitir as ações `"kms:GenerateDataKey"`, `"kms:Decrypt"` e `"kms:Encrypt"` à chave usada para criptografar os metadados. Para obter mais informações, consulte [Encrypting your Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) (Criptografar seu catálogo de dados) no *Guia do desenvolvedor do AWS Glue* e [Configurar o acesso do Athena aos metadados criptografados no AWS Glue Data Catalog](access-encrypted-data-glue-data-catalog.md).
## Permissões baseadas em recursos para buckets do Amazon S3 em contas externas (opcional)
Para consultar um local de dados do Amazon S3 em uma conta diferente, uma política do IAM baseada em recurso (política de bucket) deve permitir o acesso ao local. Para obter mais informações, consulte [Configurar o acesso entre contas do Athena aos buckets do Amazon S3](cross-account-permissions.md).
Para obter informações sobre como acessar catálogos em outra conta, consulte [Opção A: configurar o acesso entre contas ao catálogo de dados no Athena](lf-athena-limitations-cross-account.md#lf-athena-limitations-cross-account-glue).
# Usar o Lake Formation e os drivers JDBC e ODBC para acesso federado ao Athena
Os drivers Athena JDBC e ODBC permitem a federação baseada em SAML 2.0 com o Athena usando os provedores de identidade Okta e Microsoft Active Directory Federation Services (AD FS). Ao integrar o Amazon Athena com o AWS Lake Formation, você habilita a autenticação baseada em SAML no Athena com credenciais corporativas. Com o Lake Formation e o AWS Identity and Access Management (IAM), você pode manter um controle de acesso refinado no nível da coluna dos dados disponíveis para o usuário do SAML. Com os drivers Athena JDBC e ODBC, o acesso federado está disponível por ferramenta ou de modo programático.
Para usar o Athena para acessar uma origem dos dados controlada pelo Lake Formation, você precisa habilitar a federação baseada em SAML 2.0 configurando seu Identity Provider (IdP – Provedor de identidade) e as funções do AWS Identity and Access Management (IAM). Para saber detalhes das etapas, consulte [Tutorial: configurar o acesso federado ao Athena para usuários do Okta usando o Lake Formation e o JDBC](security-athena-lake-formation-jdbc-okta-tutorial.md).
## Pré-requisitos
Para usar o Amazon Athena e o Lake Formation para acesso federado, você deve atender aos seguintes requisitos:
+ Gerencie suas identidades corporativas usando um provedor de identidade baseado em SAML existente, como Okta ou Microsoft Active Directory Federation Services (AD FS).
+ Use o AWS Glue Data Catalog como um armazenamento de metadados.
+ Defina e gerencie as permissões no Lake Formation para acessar bancos de dados, tabelas e colunas no AWS Glue Data Catalog. Para obter mais informações, consulte o [Guia do desenvolvedor do AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/).
+ Use a versão 2.0.14 ou mais recente do [driver JDBC do Athena](https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html) ou a versão 1.1.3 ou mais recente do [driver ODBC do Athena](connect-with-odbc.md).
## Considerações e limitações
Ao usar o driver Athena JDBC ou ODBC e o Lake Formation para configurar o acesso federado ao Athena, tenha em mente os seguintes pontos:
+ No momento, o driver Athena JDBC e drivers ODBC são compatíveis com os provedores de identidade Okta, Microsoft Active Directory Federation Services (AD FS) e Azure AD. Embora o driver Athena JDBC tenha uma classe SAML genérica que pode ser estendida para usar outros provedores de identidade, o suporte a extensões personalizadas que permitem o uso de outros provedores de identidade (IdPs) com o Athena pode ser limitado.
+ O acesso federado usando os drivers JDBC e ODBC não é compatível com o recurso de propagação de identidade confiável do Centro de Identidade do IAM.
+ Atualmente, você não pode usar o console do Athena para configurar o suporte para uso de IdP e SAML com o Athena. Para configurar esse suporte, use o provedor de identidade de terceiro, os consoles de gerenciamento do Lake Formation e do IAM e o cliente de driver JDBC ou ODBC.
+ Você deve entender a [especificação SAML 2.0](https://www.oasis-open.org/standards#samlv2.0) e como ela funciona com seu provedor de identidade antes de configurar o provedor de identidade e o SAML para uso com o Lake Formation e o Athena.
+ Os provedores SAML e os drivers Athena JDBC e ODBC são fornecidos por terceiros, portanto, o suporte da AWS para questões relacionadas ao uso deles pode ser limitado.
**Topics**
+ [
## Pré-requisitos
](#security-athena-lake-formation-jdbc-prerequisites)
+ [
## Considerações e limitações
](#security-athena-lake-formation-jdbc-considerations-and-limitations)
+ [
# Tutorial: configurar o acesso federado ao Athena para usuários do Okta usando o Lake Formation e o JDBC
](security-athena-lake-formation-jdbc-okta-tutorial.md)
# Tutorial: configurar o acesso federado ao Athena para usuários do Okta usando o Lake Formation e o JDBC
Este tutorial mostra como configurar o Okta, o AWS Lake Formation, as permissões do AWS Identity and Access Management e o driver Athena JDBC para habilitar o uso federado baseado em SAML do Athena. O Lake Formation oferece controle de acesso refinado dos dados que estão disponíveis no Athena para o usuário baseado em SAML. Para definir essa configuração, o tutorial usa o console do desenvolvedor do Okta, os consoles do AWS IAM e do Lake Formation e a ferramenta SQL Workbench/J.
**Pré-requisitos**
Este tutorial pressupõe que você tenha feito o seguinte:
+ Criado uma conta da Amazon Web Services. Para criar uma conta, acesse a [home page da Amazon Web Services](https://aws.amazon.com/).
+ [Configurado um local de resultados de consultas](query-results-specify-location.md) do Athena no Amazon S3.
+ [Registrado um local de bucket de dados do Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html) no Lake Formation.
+ Definido um [banco de dados](https://docs.aws.amazon.com/glue/latest/dg/define-database.html) e [tabelas](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html) no [Catálogo de Dados do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) que aponte para seus dados no Amazon S3.
+ Se você ainda não definiu uma tabela, [execute um crawler do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) ou [use o Athena para definir um banco de dados e uma ou mais tabelas](work-with-data.md) para os dados que deseja acessar.
+ Este tutorial usa uma tabela baseada no [conjunto de dados de trajetos de táxi na cidade de Nova York](https://registry.opendata.aws/nyc-tlc-trip-records-pds/) disponível no [Registry of Open Data on AWS](https://registry.opendata.aws/) (Registro aberto de dados na ). O tutorial usa o nome do banco de dados `tripdb` e o nome da tabela`nyctaxi`.
**Topics**
+ [
## Etapa 1: Criar uma conta do Okta
](#security-athena-lake-formation-jdbc-okta-tutorial-step-1-create-an-okta-account)
+ [
## Etapa 2: Adicionar usuários e grupos ao Okta
](#security-athena-lake-formation-jdbc-okta-tutorial-step-2-set-up-an-okta-application-for-saml-authentication)
+ [
## Etapa 3: Configurar uma aplicação do Okta para autenticação SAML
](#security-athena-lake-formation-jdbc-okta-tutorial-step-3-set-up-an-okta-application-for-saml-authentication)
+ [
## Etapa 4: Criar um provedor de identidade SAML para AWS e uma função do IAM para acesso ao Lake Formation
](#security-athena-lake-formation-jdbc-okta-tutorial-step-4-create-an-aws-saml-identity-provider-and-lake-formation-access-IAM-role)
+ [
## Etapa 5: Adicionar a função do IAM e o provedor de identidade SAML à aplicação do Okta
](#security-athena-lake-formation-jdbc-okta-tutorial-step-5-update-the-okta-application-with-the-aws-role-and-saml-identity-provider)
+ [
## Etapa 6: Conceder permissões de usuário e grupo pelo AWS Lake Formation
](#security-athena-lake-formation-jdbc-okta-tutorial-step-6-grant-permissions-through-aws-lake-formation)
+ [
## Etapa 7: Verificar o acesso pelo cliente Athena JDBC
](#security-athena-lake-formation-jdbc-okta-tutorial-step-7-verify-access-through-athena-jdbc-client)
+ [
## Conclusão
](#security-athena-lake-formation-jdbc-okta-tutorial-conclusion)
+ [
## Recursos relacionados
](#security-athena-lake-formation-jdbc-okta-tutorial-related-resources)
## Etapa 1: Criar uma conta do Okta
Este tutorial usa o Okta como provedor de identidade baseado em SAML. Se você ainda não tem uma conta do Okta, pode criar uma gratuitamente. Ela é necessária para que você possa criar uma aplicação do Okta para autenticação SAML.
**Para criar uma conta do Okta**
1. Para usar o Okta, navegue até a [página de cadastro de desenvolvedor do Okta](https://developer.okta.com/signup/) e crie uma conta de avaliação gratuita. O Developer Edition Service é gratuito dentro dos limites especificados pelo Okta em [developer.okta.com/pricing](https://developer.okta.com/pricing).
1. Quando você receber o e-mail de ativação, ative sua conta.
Um nome de domínio do Okta será atribuído a você. Salve-o para referência. Mais tarde, você usará o nome de domínio (**) na string JDBC que se conecta ao Athena.
## Etapa 2: Adicionar usuários e grupos ao Okta
Nesta etapa, você usa o console do Okta para executar as seguintes tarefas:
+ Criar dois usuários do Okta.
+ Criar dois grupos do Okta.
+ Adicionar um usuário a cada grupo do Okta.
**Para adicionar usuários ao Okta**
1. Depois de ativar sua conta do Okta, faça login como usuário administrativo no domínio do Okta atribuído.
1. No painel de navegação à esquerda, escolha **Directory** (Diretório) e **People** (Pessoas).
1. Escolha **Add Person** (Adicionar pessoa) para adicionar um novo usuário que acessará o Athena por meio do driver JDBC.
![\[Escolha Add Person (Adicionar pessoa).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-3.png)
1. Na caixa de diálogo **Add Person** (Adicionar pessoa), insira as informações necessárias.
+ Insira os valores em **First name** (Nome) e **Last name** (Sobrenome). Este tutorial usa o *athena-okta-user*.
+ Insira um **Username** (Nome de usuário) e **Primary email** (E-mail principal). Este tutorial usa o *athena-okta-user@anycompany.com*.
+ Em **Password** (Senha), escolha **Set by admin** (Definir por administrador) e insira uma senha. Neste tutorial, a opção **User must change password on first login** (O usuário deve alterar a senha no primeiro login) está desmarcada, mas seus requisitos de segurança podem variar.
![\[Adicione um usuário à aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4.png)
1. Escolha **Save and Add Another** (Salvar e adicionar outro).
1. Insira as informações do outro usuário. Este exemplo adiciona o usuário analista de negócios *athena-ba-user@anycompany.com*.
![\[Adicione um usuário à aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4a.png)
1. Escolha **Salvar**.
No procedimento a seguir, você concede acesso a dois grupos do Okta por meio do driver Athena JDBC adicionando um grupo “Business Analysts” e um grupo “Developer”.
**Para adicionar grupos do Okta**
1. No painel de navegação do Okta, escolha **Directory** (Diretório) e **Groups** (Grupos).
1. Na página **Groups** (Grupos), escolha **Add Group** (Adicionar grupo).
![\[Escolha Adicionar grupo.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4c.png)
1. Na caixa de diálogo **Add Group** (Adicionar grupo), insira as informações necessárias.
+ Em **Name** (Nome), insira *lf-business-analyst*.
+ Em **Group Description** (Descrição do grupo), insira *Business Analysts* (Analistas de negócios).
![\[Adicionar um grupo do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4d.png)
1. Escolha **Adicionar grupo**.
1. Na página **Groups** (Grupos), escolha **Add Group** (Adicionar grupo) novamente. Desta vez, você insere as informações do grupo Developer.
1. Insira as informações necessárias.
+ Em **Name** (Nome), insira *lf-developer*.
+ Em **Group Description** (Descrição do grupo), insira *Developers* (Desenvolvedores).
1. Escolha **Adicionar grupo**.
Agora que você tem dois usuários e dois grupos, está pronto para adicionar um usuário a cada grupo.
**Para adicionar usuários a grupos**
1. Na página **Groups** (Grupos), escolha o grupo **lf-developer** que você acabou de criar. Adicione a esse grupo um dos usuários do Okta que você criou como desenvolvedor.
![\[Escolha lf-developer.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4f.png)
1. Escolha **Manage People** (Gerenciar pessoas).
![\[Escolha Manage People (Gerenciar pessoas).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4g.png)
1. Na lista **Not Members** (Não membros), escolha **athena-okta-user**.
![\[Escolha um usuário para adicionar à lista de membros.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4h.png)
A entrada referente ao usuário é transferida da lista **Not Members** (Não membros) à esquerda para a lista **Members** (Membros) à direita.
![\[Usuário do Okta adicionado a um grupo do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4i.png)
1. Escolha **Salvar**.
1. Escolha **Back to Group** (Voltar ao grupo) ou **Directory** (Diretório) e selecione **Groups** (Grupos).
1. Escolha o grupo **lf-business-analyst**.
1. Escolha **Manage People** (Gerenciar pessoas).
1. Adicione o **athena-ba-user** à lista **Members** (Membros) do grupo **lf-business-analyst** e escolha **Save** (Salvar).
1. Escolha **Back to Group** (Voltar ao grupo) ou **Directory** (Diretório) e selecione **Groups** (Grupos).
A página **Groups** (Grupos) agora mostra cada grupo com um usuário do Okta.
![\[Um usuário foi adicionado a cada grupono console do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-4j.png)
## Etapa 3: Configurar uma aplicação do Okta para autenticação SAML
Nesta etapa, você usa o console de desenvolvedor do Okta para executar as seguintes tarefas:
+ Adicionar uma aplicação do SAML para usar com a AWS.
+ Atribuir a aplicação a um usuário do Okta.
+ Atribuir a aplicação a um grupo do Okta.
+ Baixe os metadados resultantes do provedor de identidade para uso posterior com a AWS.
**Para adicionar uma aplicação para autenticação SAML**
1. No painel de navegação do Okta, escolha **Applications** (Aplicações), **Applications** (Aplicações) para configurar uma aplicação do Okta para autenticação SAML no Athena.
1. Clique em **Browse App Catalog** (Procurar no catálogo de aplicações).
1. Na caixa de pesquisa, insira **Redshift**.
1. Escolha **Amazon Web Services Redshift**. Neste tutorial, a aplicação do Okta usa a integração existente com SAML para Amazon Redshift.
![\[Escolha Amazon Web Services Redshift.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-7.png)
1. Na página **Amazon Web Services Redshift**, escolha **Add** (Adicionar) para criar uma aplicação baseada em SAML para o Amazon Redshift.
![\[Escolha Add (Adicionar) para criar uma aplicação baseada em SAML.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-8.png)
1. Em **Application label** (Rótulo da aplicação), insira `Athena-LakeFormation-Okta` e escolha **Done** (Concluído).
![\[Insira um nome para a aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-9.png)
Agora que você criou uma aplicação do Okta, pode atribuí-la aos usuários e grupos criados.
**Para atribuir uma aplicação a usuários e grupos**
1. Na página **Applications** (Aplicações), escolha a aplicação **Athena-LakeFormation-Okta**.
1. Na guia **Assignments** (Atribuições), escolha **Assign** (Atribuir), **Assign to People** (Atribuir a pessoas).
![\[Escolha Assign (Atribuir), Assign to People (Atribuir a pessoas).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-10.png)
1. Na caixa de diálogo **Assign Athena-LakeFormation-Okta to People** (Atribuir Athena-LakeFormation-Okta a pessoas), encontre o usuário **athena-okta-user** que você criou.
1. Escolha **Assign** (Atribuir) para atribuir o usuário à aplicação.
![\[Selecione Assign (Atribuir).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-11.png)
1. Escolha **Save and Go Back** (Salvar e voltar).
1. Selecione **Concluído**.
1. Na guia **Assignments** (Atribuições) da aplicação **Athena-LakeFormation-Okta**, escolha **Assign** (Atribuir), **Assign to Groups** (Atribuir a grupos).
1. Em **lf-business-analyst**, escolha **Assign** (Atribuir) para atribuir a aplicação **Athena-LakeFormation-Okta** ao grupo **lf-business-analyst** e escolha **Done** (Concluído).
![\[Atribuir uma aplicação do Okta a um grupo de usuários do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-12b.png)
O grupo aparecerá na lista de grupos da aplicação.
![\[A aplicação do Okta é atribuída ao grupo do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-12c.png)
Agora você está pronto para baixar os metadados da aplicação do provedor de identidade para uso com a AWS.
**Para baixar os metadados da aplicação**
1. Escolha a guia **Sign On** (Logon) da aplicação do Okta e clique com o botão direito em **Identity Provider metadata** (Metadados do provedor de identidade).
![\[Clique com o botão direito em Identity Provider metadata (Metadados do provedor de identidade).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-13.png)
1. Escolha **Save Link As** (Salvar link como) para salvar os metadados do provedor de identidade, que estão no formato XML, em um arquivo. Dê a ele um nome que você reconhece (por exemplo, `Athena-LakeFormation-idp-metadata.xml`).
![\[Salvar os metadados do provedor de identidade.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-14.png)
## Etapa 4: Criar um provedor de identidade SAML para AWS e uma função do IAM para acesso ao Lake Formation
Nesta etapa, use o console do AWS Identity and Access Management (IAM) para executar as seguintes tarefas:
+ Criar um provedor de identidade para AWS.
+ Criar uma função do IAM para acesso ao Lake Formation.
+ Adicionar a política gerenciada AmazonAthenaFullAccess à função.
+ Adicionar uma política para Lake Formation e AWS Glue à função.
+ Adicionar uma política para os resultados das consultas do Athena à função.
**Para criar um provedor de identidade SAML para AWS**
1. Faça login no **console** da **conta da Amazon Web Services** como **administrador da conta da Amazon Web Services** e navegue até o console do **IAM** ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).
1. No painel de navegação, escolha **Identity providers** (Provedores de identidade) e clique em **Add provider** (Adicionar provedor).
1. Na tela **Configure provider** (Configurar provedor), insira as seguintes informações:
+ Em **Provider type** (Tipo de provedor), escolha **SAML**.
+ Em **Provider name** (Nome do provedor), insira `AthenaLakeFormationOkta`.
+ Em **Metadata document** (Documento de metadados), use a opção **Choose file** (Escolher arquivo) para carregar o arquivo XML de metadados do provedor de identidade (IdP) que você baixou.
1. Escolha **Add provider** (Adicionar provedor).
Em seguida, você cria uma função do IAM para acesso ao AWS Lake Formation. Adicione duas políticas em linha à função. Uma política concede permissões para acessar o Lake Formation e as APIs do AWS Glue. A outra política concede acesso ao Athena e ao local de resultados das consultas do Athena no Amazon S3.
**Para criar uma função do IAM para acesso ao AWS Lake Formation**
1. No painel de navegação do console do IAM, escolha **Roles** (Funções) e **Create role** (Criar função).
1. Na página **Create role** (Criar função), siga estas etapas:
![\[Configure uma função do IAM para usar o SAML 2.0.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-20.png)
1. Em **Select type of trusted entity** (Selecionar tipo de entidade confiável), escolha **SAML 2.0 Federation**.
1. Em **SAML provider** (Provedor SAML), selecione **AthenaLakeFormationOkta**.
1. Em **SAML provider** (Provedor SAML), selecione a opção **Allow programmatic and Console de gerenciamento da AWS access** (Permitir acesso programático e por console).
1. Escolha **Próximo: Permissões**.
1. Na página **Attach Permissions policies** (Anexar políticas de permissões), em **Filter policies** (Filtrar políticas), insira **Athena**.
1. Selecione a política gerenciada **AmazonAthenaFullAccess** e escolha **Next: Tags** (Próximo: etiquetas).
![\[Anexar a política gerenciada AmazonAthenaFullAccess à função do IAM.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-21.png)
1. Na página **Add tags (Adicionar tags)**, escolha **Next: Review(Próximo: Revisar)**.
1. Na página **Review** (Revisão), em **Role name** (Nome da função), insira um nome para a função (por exemplo, *Athena-LakeFormation-OktaRole*) e escolha **Create role** (Criar função).
![\[Insira um nome para a função do IAM.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-22.png)
Na sequência, adicione as políticas em linha que permitem o acesso ao Lake Formation, às APIs do AWS Glue e aos resultados das consultas do Athena no Amazon S3.
Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Manual do usuário do IAM*.
**Para adicionar uma política em linha à função para o Lake Formation e o AWS Glue**
1. Na lista de funções no console do IAM, escolha a recém-criada `Athena-LakeFormation-OktaRole`.
1. Na página **Summary** (Resumo) da função, na guia **Permissions** (Permissões), escolha **Add inline policy** (Adicionar política em linha).
1. Na página **Create policy (Criar política)**, escolha **JSON**.
1. Adicione uma política em linha, semelhante à mostrada abaixo, que concede acesso ao Lake Formation e às APIs do AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:GetTable",
"glue:GetTables",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:CreateDatabase",
"glue:GetUserDefinedFunction",
"glue:GetUserDefinedFunctions"
],
"Resource": "*"
}
}
```
------
1. Selecione **Revisar política**.
1. Em **Name** (Nome), insira um nome para a política (por exemplo, **LakeFormationGlueInlinePolicy**).
1. Escolha **Criar política**.
**Para adicionar uma política em linha à função para o local de resultados das consultas do Athena**
1. Na página **Summary** (Resumo) da função `Athena-LakeFormation-OktaRole`, na guia **Permissions** (Permissões), escolha **Add inline policy** (Adicionar política em linha).
1. Na página **Create policy (Criar política)**, escolha **JSON**.
1. Adicione uma política em linha, semelhante à mostrada abaixo, que permite o acesso da função ao local de resultados das consultas do Athena. Substitua os espaços reservados ** no exemplo pelo nome do seu bucket do Amazon S3.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AthenaQueryResultsPermissionsForS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::",
"arn:aws:s3:::/*"
]
}
]
}
```
------
1. Selecione **Revisar política**.
1. Em **Name** (Nome), insira um nome para a política (por exemplo, **AthenaQueryResultsInlinePolicy**).
1. Escolha **Criar política**.
Na sequência, copie o ARN da função de acesso do Lake Formation e o ARN do provedor SAML criado. Eles serão necessários para você configurar a aplicação SAML do Okta na próxima seção do tutorial.
**Para copiar o ARN da função e o ARN do provedor de identidade SAML**
1. No console do IAM, na página **Summary** (Resumo) da função `Athena-LakeFormation-OktaRole`, escolha o ícone **Copy to clipboard** (Copiar para área de transferência) ao lado de **Role ARN** (ARN da função). O ARN tem o seguinte formato:
```
arn:aws:iam:::role/Athena-LakeFormation-OktaRole
```
1. Salve o ARN completo com segurança para referência futura.
1. No painel de navegação do console do IAM, escolha **Identity providers** (Provedores de identidade).
1. Escolha o provedor **AthenaLakeFormationOkta**.
1. Na página **Summary** (Resumo), escolha o ícone **Copy to clipboard** (Copiar para área de transferência) ao lado de **Provider ARN** (ARN do provedor). O Nome de região da Amazon (ARN) deve se parecer com o seguinte:
```
arn:aws:iam:::saml-provider/AthenaLakeFormationOkta
```
1. Salve o ARN completo com segurança para referência futura.
## Etapa 5: Adicionar a função do IAM e o provedor de identidade SAML à aplicação do Okta
Nesta etapa, você retorna ao console de desenvolvedor do Okta e executa as seguintes tarefas:
+ Adicionar atributos de URL do Lake Formation de usuário e de grupo à aplicação do Okta.
+ Adicionar o ARN do provedor de identidade e da função do IAM à aplicação do Okta.
+ Copiar o ID da aplicação do Okta. O ID da aplicação do Okta é necessário no perfil JDBC que se conecta ao Athena.
**Para adicionar atributos de URL do Lake Formation de usuário e de grupo à aplicação do Okta**
1. Faça login no console de desenvolvedor do Okta.
1. Escolha a guia **Applications** (Aplicações) e selecione a aplicação `Athena-LakeFormation-Okta`.
1. Escolha a guia **Sign On** (Logon) da aplicação e selecione **Edit** (Editar).
![\[Edite a aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-24.png)
1. Escolha **Attributes (optional)** (Atributos (opcional)) para expandi-los.
![\[Adicionar atributos de URL do Lake Formation de usuário à aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-25.png)
1. Em **Attribute Statements (optional)** (Instruções do atributo (opcional)), adicione o seguinte atributo:
+ Em **Nome**, digite **https://lakeformation.amazon.com/SAML/Attributes/Username**.
+ Em **Value** (Valor), insira **user.login**
1. Em **Group Attribute Statements (optional)** (Instruções do atributo de grupo (opcional)), adicione o seguinte atributo:
+ Em **Nome**, digite **https://lakeformation.amazon.com/SAML/Attributes/Groups**.
+ Em **Name format** (Formato de nome), insira **Basic**
+ Em **Filter** (Filtro), escolha **Matches regex** (Corresponde a regex) e insira **.\$1** na caixa do filtro.
![\[Adicionar atributos de URL do Lake Formation de grupo à aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-25a.png)
1. Role para baixo até a seção **Advanced Sign-On Settings** (Configurações avançadas de logon), na qual você adiciona os ARNs do provedor de identidade e da função do IAM à aplicação do Okta.
**Para adicionar os ARNs do provedor de identidade e da função do IAM à aplicação do Okta**
1. Em **Idp ARN and Role ARN** (ARN do ldp e ARN da função), insira o ARN do provedor de identidade da AWS e o ARN da função como valores separados por vírgulas no formato **,**. A string combinada deve ter a seguinte aparência:
```
arn:aws:iam:::saml-provider/AthenaLakeFormationOkta,arn:aws:iam:::role/Athena-LakeFormation-OktaRole
```
![\[Inserir o ARN do provedor de identidade e o ARN da função do IAM na aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-26.png)
1. Escolha **Salvar**.
Em seguida, copie o ID da aplicação do Okta. Você precisará dele mais tarde para a string JDBC que se conecta ao Athena.
**Para localizar e copiar o ID da aplicação do Okta.**
1. Escolha a guia **General** (Geral) da aplicação do Okta.
![\[Escolha a guia General (Geral) da aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-27.png)
1. Rola para baixo até a seção **App Embed Link** (Link de incorporação de aplicação).
1. Em **Embed Link** (Link de incorporação), copie e salve a parte do URL da aplicação do Okta com segurança. O ID da aplicação do Okta é a parte do URL que vem depois de `amazon_aws_redshift/`, mas antes da próxima barra. Por exemplo, se o URL incluir `amazon_aws_redshift/aaa/bbb`, o ID da aplicação será `aaa`.
![\[Copie o ID da aplicação do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-28.png)
**nota**
O link de incorporação não pode ser usado para fazer login diretamente no console do Athena para a exibição bancos de dados. As permissões do Lake Formation para usuários e grupos SAML são reconhecidas somente quando você utiliza o driver JDBC ou ODBC para enviar consultas ao Athena. Para exibir os bancos de dados, é possível utilizar usar a ferramenta SQL Workbench/J, que usa o driver JDBC para se conectar ao Athena. A ferramenta SQL Workbench/J é discutida em [Etapa 7: Verificar o acesso pelo cliente Athena JDBC](#security-athena-lake-formation-jdbc-okta-tutorial-step-7-verify-access-through-athena-jdbc-client).
## Etapa 6: Conceder permissões de usuário e grupo pelo AWS Lake Formation
Nesta etapa, você usa o console do Lake Formation para conceder permissões em uma tabela ao usuário e grupo do SAML. Você executa as seguintes tarefas:
+ Especificar o ARN do usuário SAML do Okta e as permissões do usuário associadas na tabela.
+ Especificar o ARN do grupo SAML do Okta e as permissões do grupo associadas na tabela.
+ Verificar as permissões que você concedeu.
**Para conceder permissões no Lake Formation para o usuário do Okta**
1. Faça login como administrador de data lake no Console de gerenciamento da AWS.
1. Abra o console do Lake Formation em [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. No painel de navegação, escolha **Tables** (Tabelas) e selecione a tabela à qual você deseja conceder as permissões. Este tutorial usa a tabela `nyctaxi` do banco de dados `tripdb`.
![\[Escolha a tabela à qual deseja conceder as permissões.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-29.png)
1. Em **Actions** (Ações), escolha **Grant** (Conceder).
![\[Escolha Grant (Conceder).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-30.png)
1. Na caixa de diálogo **Grant permissions** (Conceder permissões), insira as seguintes informações:
1. Em **Usuários e grupos do SAML e do Amazon Quick**, insira o ARN do usuário SAML do Okta no seguinte formato:
```
arn:aws:iam:::saml-provider/AthenaLakeFormationOkta:user/@
```
1. Em **Columns** (Colunas), **Choose filter type** (Escolher tipo de filtro), escolha **Include columns** (Incluir colunas) ou **Exclude columns** (Excluir colunas) conforme desejado.
1. Use o menu suspenso **Choose one or more columns** (Escolher uma ou mais colunas) do filtro para especificar as colunas que você deseja incluir ou excluir do usuário.
1. Em **Table permissions** (Permissões de tabela), escolha **Select** (Selecionar). Este tutorial concede apenas as permissões `SELECT`, seus requisitos podem variar.
![\[Conceder permissões no nível da tabela e da coluna a um usuário do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-31.png)
1. Escolha **Grant** (Conceder).
Agora você executa as mesmas etapas para o grupo do Okta.
**Para conceder permissões no Lake Formation ao grupo do Okta**
1. Na página **Tables** (Tabelas) do console do Lake Formation, verifique se a tabela **nyctaxi** ainda está selecionada.
1. Em **Actions** (Ações), escolha **Grant** (Conceder).
1. Na caixa de diálogo **Grant permissions** (Conceder permissões), insira as seguintes informações:
1. Em **Usuários e grupos do SAML e do Amazon Quick**, insira o ARN do grupo SAML do Okta no seguinte formato:
```
arn:aws:iam:::saml-provider/AthenaLakeFormationOkta:group/lf-business-analyst
```
1. Em **Columns** (Colunas), **Choose filter type** (Escolher tipo de filtro), escolha **Include columns** (Incluir colunas).
1. Em **Choose one or more columns** (Escolher uma ou mais colunas), escolha as primeiras três colunas da tabela.
1. Em **Table permissions** (Permissões de tabela), escolha as permissões de acesso específicas para conceder. Este tutorial concede apenas as permissões `SELECT`, seus requisitos podem variar.
![\[Conceder permissões de tabela a um grupo do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-31b.png)
1. Escolha **Grant** (Conceder).
1. Para verificar as permissões concedidas, escolha **Actions** (Ações), **View permissions** (Visualizar permissões).
![\[Escolha View permissions (Visualizar permissões) para verificar as permissões concedidas.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-32.png)
A página **Permissões de dados** da tabela `nyctaxi` mostra as permissões do **athena-okta-user** e do grupo **lf-business-analyst**.
![\[Visualizar as permissões concedidas ao usuário e grupo do Okta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-33.png)
## Etapa 7: Verificar o acesso pelo cliente Athena JDBC
Agora você está pronto para usar um cliente JDBC para executar uma conexão de teste com o Athena como usuário SAML do Okta.
Nesta seção, você pode executar as seguintes tarefas:
+ Preparar o cliente de teste: baixe o driver Athena JDBC, instale o SQL Workbench e adicione o driver ao Workbench. Este tutorial usa o SQL Workbench para acessar o Athena por meio da autenticação do Okta e verificar as permissões do Lake Formation.
+ No SQL Workbench:
+ Crie uma conexão para o usuário do Okta no Athena.
+ Execute as consultas de teste como o usuário do Okta no Athena.
+ Crie e teste uma conexão para o usuário “analista de negócios”.
+ No console do Okta, adicione o usuário “analista de negócios” ao grupo de desenvolvedores.
+ No console do Lake Formation, configure as permissões de tabela para o grupo de desenvolvedores.
+ No SQL Workbench, execute as consultas de teste como o usuário “analista de negócios” e verifique como a alteração nas permissões afeta os resultados.
**Para preparar o cliente de teste**
1. Baixe e extraia o driver Athena JDBC compatível com o Lake Formation (2.0.14 ou versão mais recente) em [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md).
1. Baixe e instale a ferramenta de consulta SQL gratuita [SQL Workbench/J](https://www.sql-workbench.eu/index.html), disponível na licença modificada do Apache 2.0.
1. No SQL Workbench, escolha **File** (Arquivo) e **Manage Drivers** (Gerenciar drivers).
![\[Escolha Manage Drivers (Gerenciar drivers).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-1.png)
1. Na caixa de diálogo **Manage Drivers** (Gerenciar drivers), execute as seguintes etapas:
1. Escolha o ícone do novo driver.
1. Em **Name** (Nome), insira **Athena**.
1. Em **Library** (Biblioteca), procure e escolha o arquivo `.jar` do Simba Athena JDBC que você acabou de baixar.
1. Escolha **OK**.
![\[Adicionar o driver Athena JDBC ao SQL Workbench.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-2.png)
Agora você está pronto para criar e testar uma conexão para o usuário do Okta no Athena.
**Para criar uma conexão para o usuário do Okta**
1. Escolha **File** (Arquivo), **Connect window** (Conectar janela).
![\[Escolha Connect window (Conectar janela).\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-3.png)
1. Na caixa de diálogo **Connection profile** (Perfil de conexão), crie uma conexão inserindo as seguintes informações:
+ Na caixa do nome, insira **Athena\$1Okta\$1User\$1Connection**.
+ Em **Driver**, escolha o driver Simba Athena JDBC.
+ Em **URL**, realize um destes procedimentos:
+ Para usar um URL de conexão, insira uma string de conexão de linha única. O exemplo a seguir contém quebras de linha para facilitar a leitura.
```
jdbc:awsathena://AwsRegion=region-id;
S3OutputLocation=s3://amzn-s3-demo-bucket/athena_results;
AwsCredentialsProviderClass=com.simba.athena.iamsupport.plugin.OktaCredentialsProvider;
user=athena-okta-user@anycompany.com;
password=password;
idp_host=okta-idp-domain;
App_ID=okta-app-id;
SSL_Insecure=true;
LakeFormationEnabled=true;
```
+ Para usar um URL baseado no perfil da AWS, execute as seguintes etapas:
1. Configure um [perfil da AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html) que tenha um arquivo de credenciais da AWS, como mostrado no exemplo a seguir.
```
[athena_lf_dev]
plugin_name=com.simba.athena.iamsupport.plugin.OktaCredentialsProvider
idp_host=okta-idp-domain
app_id=okta-app-id
uid=athena-okta-user@anycompany.com
pwd=password
```
1. Em **URL**, insira uma string de conexão de linha única, como mostrado no exemplo a seguir. O exemplo contém quebras de linha para facilitar a leitura.
```
jdbc:awsathena://AwsRegion=region-id;
S3OutputLocation=s3://amzn-s3-demo-bucket/athena_results;
profile=athena_lf_dev;
SSL_Insecure=true;
LakeFormationEnabled=true;
```
Observe que esses exemplos são representações básicas do URL necessário para se conectar ao Athena. Para ver a lista completa dos parâmetros permitidos na URL, consulte a [documentação do JDBC](connect-with-jdbc.md).
A imagem a seguir mostra um perfil de conexão do SQL Workbench que usa um URL de conexão.
![\[Um perfil de conexão no SQL Workbench.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-4.png)
Agora que você estabeleceu uma conexão para o usuário do Okta, pode testá-la recuperando alguns dados.
**Para testar a conexão do usuário do Okta**
1. Escolha **Test** (Testar) e verifique se a conexão foi estabelecida.
1. Na janela **Statement** (Instrução) do SQL Workbench, execute o comando SQL `DESCRIBE` a seguir. Verifique se todas as colunas são exibidas.
```
DESCRIBE "tripdb"."nyctaxi"
```
![\[Todas as colunas exibidas.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-5.png)
1. Na janela **Statement** (Instrução) do SQL Workbench, execute o comando SQL `SELECT` a seguir. Verifique se todas as colunas são exibidas.
```
SELECT * FROM tripdb.nyctaxi LIMIT 5
```
![\[Verifique se todas as colunas são exibidas.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-6.png)
Na sequência, verifique se o **athena-ba-user**, como membro do grupo **lf-business-analyst**, tem acesso apenas às primeiras três colunas da tabela que você especificou anteriormente no Lake Formation.
**Para verificar o acesso do **athena-ba-user****
1. No SQL Workbench, na caixa de diálogo **Connection profile** (Perfil de conexão), crie outro perfil de conexão.
+ Para o nome do perfil de conexão, insira ** Athena\$1Okta\$1Group\$1Connection**.
+ Em **Driver**, escolha o driver Simba Athena JDBC.
+ Em **URL**, realize um destes procedimentos:
+ Para usar um URL de conexão, insira uma string de conexão de linha única. O exemplo a seguir contém quebras de linha para facilitar a leitura.
```
jdbc:awsathena://AwsRegion=region-id;
S3OutputLocation=s3://amzn-s3-demo-bucket/athena_results;
AwsCredentialsProviderClass=com.simba.athena.iamsupport.plugin.OktaCredentialsProvider;
user=athena-ba-user@anycompany.com;
password=password;
idp_host=okta-idp-domain;
App_ID=okta-application-id;
SSL_Insecure=true;
LakeFormationEnabled=true;
```
+ Para usar um URL baseado no perfil da AWS, execute as seguintes etapas:
1. Configure um perfil da AWS que tenha um arquivo de credenciais, como mostrado no exemplo a seguir.
```
[athena_lf_ba]
plugin_name=com.simba.athena.iamsupport.plugin.OktaCredentialsProvider
idp_host=okta-idp-domain
app_id=okta-application-id
uid=athena-ba-user@anycompany.com
pwd=password
```
1. Em **URL**, insira uma string de conexão de linha única, como mostrado a seguir. O exemplo contém quebras de linha para facilitar a leitura.
```
jdbc:awsathena://AwsRegion=region-id;
S3OutputLocation=s3://amzn-s3-demo-bucket/athena_results;
profile=athena_lf_ba;
SSL_Insecure=true;
LakeFormationEnabled=true;
```
1. Escolha **Test** (Testar) para confirmar se a conexão foi estabelecida.
1. Na janela **SQL Statement** (Instrução SQL), execute os mesmos comandos SQL `DESCRIBE` e `SELECT` de antes e confira os resultados.
Como o **athena-ba-user** é membro do grupo **lf-business-analyst**, apenas as três primeiras colunas que você especificou no console do Lake Formation são retornadas.
![\[Somente as três primeiras colunas são retornadas.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-7.png)
![\[Dados das três primeiras colunas.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-8.png)
Depois disso, retorne ao console do Okta para adicionar o `athena-ba-user` ao grupo do Okta `lf-developer`.
**Para adicionar o athena-ba-user ao grupo lf-developer**
1. Faça login no console do Okta como usuário administrativo do domínio do Okta atribuído.
1. Escolha **Directory** (Diretório) e **Groups** (Grupos).
1. Na página Groups (Grupos), escolha o grupo **lf-developer**.
![\[Escolha o grupo lf-developer.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-9.png)
1. Escolha **Manage People** (Gerenciar pessoas).
1. Na lista **Not Members** (Não membros), escolha o **athena-ba-user** para adicionar ao **grupo lf-developer**.
1. Escolha **Salvar**.
Agora você retorna ao console do Lake Formation para configurar as permissões de tabela do grupo **lf-developer**.
**Para configurar as permissões de tabela do grupo lf-developer**
1. Faça login no console do Lake Formation como administrador do data lake.
1. No painel de navegação, selecione **Tabelas**.
1. Selecione a tabela **nyctaxi**.
1. Escolha **Actions** (Ações), **Grant** (Conceder).
1. Na caixa de diálogo **Grant Permissions** (Conceder permissões), insira as seguintes informações:
+ Em **Usuários e grupos do SAML e do Amazon Quick**, insira o ARN do grupo SAML lf-developer do Okta no seguinte formato:
+ Em **Columns** (Colunas), **Choose filter type** (Escolher tipo de filtro), escolha **Include columns** (Incluir colunas).
+ Escolha a coluna **trip\$1type**.
+ Em **Table permissions** (Permissões de tabela), escolha **SELECT**.
1. Escolha **Grant** (Conceder).
Agora você pode usar o SQL Workbench para verificar a alteração nas permissões do grupo **lf-developer**. A alteração deve ser refletida nos dados disponíveis ao **athena-ba-user**, que agora é membro do grupo **lf-developer**.
**Para verificar a alteração nas permissões do athena-ba-user**
1. Feche e reabra o programa SQL Workbench.
1. Conecte-se ao perfil do **athena-ba-user**.
1. Na janela **Statement** (Instrução), emita as mesmas instruções SQL que você executou antes:
Desta vez, a coluna **trip\$1type** é exibida.
![\[A quarta coluna está disponível para consulta.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-10.png)
Como o **athena-ba-user** agora é membro dos dois grupos **lf-developer** e **lf-business-analyst**, a combinação das permissões do Lake Formation desses grupos determina as colunas que são retornadas.
![\[A quarta coluna nos resultados dos dados.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/security-athena-lake-formation-jdbc-okta-tutorial-verify-access-11.png)
## Conclusão
Neste tutorial, você configurou a integração do Athena com o AWS Lake Formationusando o Okta como provedor SAML. Você usou o Lake Formation e o IAM para controlar os recursos disponíveis ao usuário SAML no Catálogo de dados do AWS Glue do seu data lake.
## Recursos relacionados
Para obter informações relacionadas, consulte os recursos a seguir.
+ [Conectar ao Amazon Athena com JDBC](connect-with-jdbc.md)
+ [Habilitar o acesso federado à API do Athena](access-federation-saml.md)
+ [AWS Lake Formation Guia do desenvolvedor do](https://docs.aws.amazon.com/lake-formation/latest/dg/)
+ [Granting and revoking Data Catalog permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) (Conceder e revogar permissões de catálogo de dados) no *Guia do desenvolvedor do AWS Lake Formation*.
+ [Provedores de identidade e federação](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html) no *Guia do usuário do IAM*.
+ [Criação de provedores de identidade SAML do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html) no *Guia do usuário do IAM*.
+ [Habilitar a federação na AWS usando Windows Active Directory, ADFS e SAML 2.0](https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/) no *blog de segurança da AWS*.
# Gerenciamento do workload
Você pode usar os recursos de grupo de trabalho, gerenciamento de capacidade, ajuste de performance, suporte à compactação, etiquetas e cotas de serviço do Athena para gerenciar sua workload.
**Topics**
+ [
# Usar grupos de trabalho para controlar o acesso a consultas e os custos
](workgroups-manage-queries-control-costs.md)
+ [
# Gerenciar a capacidade de processamento de consulta
](capacity-management.md)
+ [
# Otimizar a performance do Athena
](performance-tuning.md)
+ [
# Usar compactação no Athena
](compression-formats.md)
+ [
# Marcar recursos do Athena com tags
](tags.md)
+ [
# Service Quotas
](service-limits.md)
# Usar grupos de trabalho para controlar o acesso a consultas e os custos
Você pode usar os grupos de trabalho do Athena para separar as workloads, controlar o acesso das equipes, impor uma configuração, monitorar as métricas de consultas e controlar os custos.
**Separar as workloads**
Você pode usar os grupos de trabalho para separar as workloads. Por exemplo, você pode criar dois grupos de trabalho independentes: um para aplicativos programados automatizados, como geração de relatórios, e outro para uso ad-hoc por analistas.
**Controlar o acesso das equipes**
Como os grupos de trabalho funcionam como recursos do IAM, você pode usar políticas baseadas em identidade no nível dos recursos para controlar quem pode acessar executar consultas em um grupo de trabalho. Para isolar as consultas de duas equipes diferentes da organização, você pode criar um grupo de trabalho separado para cada equipe. Cada grupo de trabalho tem seu próprio histórico de consultas e uma lista das consultas salvas daquele grupo, e não de todas as consultas da conta. Para obter mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md).
**Impor uma configuração**
Opcionalmente, você pode impor a todo o grupo de trabalho as mesmas configurações para todas as consultas nele executadas. As configurações incluem: local dos resultados das consultas no Amazon S3, proprietário previsto do bucket, criptografia e controle dos objetos gravados no bucket de resultados de consultas. Para obter mais informações, consulte [Override client-side settings (Substituir configurações no lado do cliente)](workgroups-settings-override.md).
**Monitorar métricas e eventos de consulta, e controlar custos**
Para monitorar as métricas e os eventos de consulta, e controlar os custos de cada grupo de trabalho do Athena, você pode usar os seguintes atributos:
+ **Publicar métricas de consultas**: publique as métricas de consultas do grupo de trabalho no CloudWatch. No console do Athena, você pode visualizar as métricas de consultas para cada um dos grupos de trabalho. No CloudWatch, você pode criar painéis personalizados e definir limites e alarmes para essas métricas. Para obter mais informações, consulte [Habilitar métricas de consultas do CloudWatch no Athena](athena-cloudwatch-metrics-enable.md) e [Monitorar métricas de consultas do Athena com o CloudWatch](query-metrics-viewing.md).
+ **Monitorar métricas de uso do Athena**: veja como a sua conta usa os recursos, exibindo o uso do serviço atual por meio de gráficos e painéis do CloudWatch. Para obter mais informações, consulte . [Monitorar métricas de uso do Athena com o CloudWatch](monitoring-athena-usage-metrics.md)
+ **Monitorar eventos de consulta**: use o Amazon EventBridge para receber notificações em tempo real sobre o estado das suas consultas. Para obter mais informações, consulte [Monitorar eventos de consulta do Athena com o EventBridge](athena-events.md).
+ **Criar controles de uso de dados**: no Athena, você pode configurar controles de uso de dados por consulta e por grupo de trabalho. O Athena cancela as consultas quando elas excedem o limite especificado ou ativa um alarme do Amazon SNS quando um limite do grupo de trabalho é violado. Para obter mais informações, consulte [Configurar controles de uso de dados por consulta e por grupo de trabalho](workgroups-setting-control-limits-cloudwatch.md).
+ **Usar tags de alocação de custos**: use o console do Billing and Cost Management para marcar os grupos de trabalho com tags de alocação de custos. Os custos associados à execução de consultas no grupo de trabalho aparecem no relatório de custos e uso com a respectiva tag de alocação de custos. Para obter mais informações, consulte [Using user-defined cost allocation tags](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) no *AWS Billing User Guide*.
+ **Usar reservas de capacidade**: você pode criar reservas de capacidade, com a quantidade de unidades de processamento de dados especificada, e adicionar um ou mais grupos de trabalho à reserva. Para obter mais informações, consulte [Gerenciar a capacidade de processamento de consulta](capacity-management.md).
Para obter mais informações sobre o uso de grupos de trabalho do Athena para separar as workloads, controlar o acesso dos usuários e gerenciar o uso e os custos das consultas, consulte a postagem [Separate queries and managing costs using Amazon Athena workgroups](https://aws.amazon.com/blogs/big-data/separating-queries-and-managing-costs-using-amazon-athena-workgroups/) no blog de big data da AWS.
**nota**
Os recursos do Amazon Athena agora podem ser acessados no Estúdio Unificado Amazon SageMaker (Preview), o que ajuda você a acessar os dados da sua organização e agir com base neles usando as melhores ferramentas. É possível migrar consultas salvas de um grupo de trabalho do Athena para um projeto do SageMaker Unified Studio, configurar projetos com grupos de trabalho existentes do Athena e manter as permissões necessárias por meio de atualizações de perfis do IAM. Para obter mais informações, consulte [Migrar recursos do Amazon Athena para o Estudio Unificado Amazon SageMaker (Preview)](https://github.com/aws/Unified-Studio-for-Amazon-Sagemaker/tree/main/migration/athena).
## Considerações e limitações
Quando você usar grupos de trabalho no Athena, tenha em mente os seguintes pontos:
+ Cada conta tem um grupo de trabalho principal. Por padrão, se você ainda não criou nenhum grupo de trabalho, todas as consultas na sua conta são executadas no grupo de trabalho principal. O grupo de trabalho principal não pode ser excluído. As permissões padrão permitem que todos os usuários autenticados acessem esse grupo de trabalho.
+ Quando você tiver acesso a um grupo de trabalho, poderá visualizar as configurações de grupo de trabalho, as métricas e os limites de controle de uso de dados. Com permissões adicionais, é possível editar as configurações e os limites de controle de uso de dados.
+ Quando você executar consultas, elas serão executadas no grupo de trabalho atual. Você pode executar consultas no contexto de um grupo de trabalho no console por meio de operações da API, da interface de linha de comando ou de uma aplicação cliente usando o driver JDBC ou ODBC.
+ No editor de consultas do console do Athena, você pode abrir até dez guias de consulta em cada grupo de trabalho. Quando você alterna entre os grupos de trabalho, as guias de consulta para até três grupos de trabalho permanecem abertas.
+ Você pode criar até mil grupos de trabalho por Região da AWS na sua conta.
+ Os grupos de trabalho podem ser desabilitados. Desabilitar um grupo de trabalho impede a execução de consultas nele até que ele seja reabilitado.
+ O Athena avisa se você tentar excluir um grupo de trabalho que contenha consultas salvas. Antes de excluir um grupo de trabalho ao qual outros usuários têm acesso, certifique-se de que eles tenham acesso a outros grupos de trabalho que possam usar para executar consultas.
**Topics**
+ [
## Considerações e limitações
](#workgroups-considerations-limitations)
+ [
# Criar um grupo de trabalho
](creating-workgroups.md)
+ [
# Gerenciar grupos de trabalho
](workgroups-create-update-delete.md)
+ [Usar o CloudWatch e o EventBridge para monitorar as consultas](workgroups-control-limits.md)
+ [
# Usar APIs de grupos de trabalho do Athena
](workgroups-api-list.md)
+ [Solucionar problemas de grupos de trabalho](workgroups-troubleshooting.md)
# Criar um grupo de trabalho
Criar um grupo de trabalho requer permissões para ações da API `CreateWorkgroup`. Consulte [Configurar o acesso a grupos de trabalho e tags](workgroups-access.md) e [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md). Se você adicionar tags, também precisará adicionar permissões para `TagResource`. Consulte [Exemplos de política de etiquetas para grupos de trabalho](tags-access-control.md#tag-policy-examples-workgroups).
O procedimento a seguir mostra como usar o console do Athena para criar um grupo de trabalho. Para criar um grupo de trabalho usando a API do Athena, consulte [CreateWorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateWorkGroup.html).
**Para criar um grupo de trabalho no console do Athena**
1. Decida quais grupos de trabalho deseja criar. Estes são alguns fatores que devem ser considerados:
+ Quem pode executar consultas em cada grupo de trabalho e de quem é a configuração do grupo de trabalho. Use as políticas do IAM para impor as permissões de grupo de trabalho. Para obter mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md).
+ O local no Amazon S3 a ser usada para os resultados das consultas do grupo de trabalho. Todos os usuários do grupo de trabalho devem ter acesso a esse local.
+ Se os resultados de consultas do grupo de trabalho devem ou não ser criptografados. Como a criptografia é definida para o grupo de trabalho (não para a consulta), você deve criar grupos de trabalho separados para resultados de consultas criptografados e não criptografados. Para obter mais informações, consulte [Criptografar os resultados de consultas do Athena armazenados no Amazon S3](encrypting-query-results-stored-in-s3.md).
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 do console do Athena, escolha **Workgroups** (Grupos de trabalho).
1. Na página **Workgroups** (Grupos de trabalho), escolha **Create workgroup** (Criar grupo de trabalho).
1. Na página **Create workgroup** (Criar grupo de trabalho), preencha os campos da seguinte forma:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/creating-workgroups.html)
1. Escolha **Create workgroup (Criar grupo de trabalho)**. O grupo de trabalho aparece na lista na página **Workgroups** (Grupos de trabalho).
No editor de consultas, o Athena exibe o grupo de trabalho atual na opção **Grupo de trabalho** no canto superior direito do console. Você pode usar essa opção para alternar grupos de trabalho. Quando você executar consultas, elas serão executadas no grupo de trabalho atual.
1. Crie políticas do IAM para seus usuários, grupos ou funções para habilitar o acesso deles aos grupos de trabalho. As políticas estabelecem a associação do grupo de trabalho e o acesso a ações em um recurso `workgroup`. Para obter mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md). Para obter exemplos de políticas em JSON, consulte [Configurar o acesso a grupos de trabalho e tags](workgroups-access.md).
1. (Opcional) Configure um nível mínimo de criptografia no Amazon S3 para todos os resultados de consultas do grupo de trabalho quando a criptografia não for imposta a todo o grupo de trabalho pela opção de substituir as configurações do lado do cliente. Use esse recurso para garantir que os resultados da consulta nunca sejam armazenados em um bucket do Amazon S3 em estado não criptografado. Para obter mais informações, consulte [Configurar criptografia mínima para um grupo de trabalho](workgroups-minimum-encryption.md).
1. (Opcional) Use o Amazon CloudWatch e o Amazon EventBridge para monitorar as consultas e controlar os custos do grupo de trabalho. Para obter mais informações, consulte [Usar o CloudWatch e o EventBridge para monitorar as consultas e controlar os custos](workgroups-control-limits.md).
1. (Opcional) Use o console do Billing and Cost Management para marcar os grupos de trabalho com tags de alocação de custos. Para obter mais informações, consulte [Using user-defined cost allocation tags](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) no *AWS Billing User Guide*.
1. (Opcional) Para ter capacidade de processamento dedicada para as consultas do grupo de trabalho, adicione o grupo de trabalho a uma reserva de capacidade. Você pode atribuir um ou mais grupos de trabalho a uma reserva. Para obter mais informações, consulte [Gerenciar a capacidade de processamento de consulta](capacity-management.md).
# Override client-side settings (Substituir configurações no lado do cliente)
Ao criar ou editar um grupo de trabalho, você pode escolher a opção **Substituir as configurações do lado do cliente**. Essa opção não é selecionada por padrão. Dependendo da sua seleção, o Athena faz o seguinte:
+ Se a opção **Substituir configurações no lado do cliente** não estiver selecionada, as configurações do grupo de trabalho não serão impostas no nível do cliente. Quando a opção de substituir as configurações do lado cliente não está selecionada para o grupo de trabalho, o Athena usa as configurações do cliente para todas as consultas executadas no grupo de trabalho, inclusive as configurações para localização dos resultados de consultas, proprietário do bucket esperado, criptografia e controle de objetos gravados no bucket de resultados de consultas. Cada usuário pode especificar as próprias configurações no menu **Configurações** no console. Se as configurações no lado do cliente não forem definidas, serão aplicadas as configurações de todo o grupo de trabalho. Se você usar a AWS CLI, ações de API ou os drivers JDBC e ODBC para executar consultas em um grupo de trabalho que não substitui as configurações do lado do cliente, suas consultas usarão as configurações especificadas em suas consultas.
+ Se a opção **Substituir configurações no lado do cliente** for selecionada, as configurações do grupo de trabalho serão impostas no nível do cliente a todos os clientes do grupo de trabalho. Quando a opção de substituir as configurações do lado cliente está selecionada para o grupo de trabalho, o Athena usa as configurações do grupo de trabalho para todas as consultas executadas no grupo de trabalho, inclusive as configurações para localização dos resultados de consultas, proprietário do bucket esperado, criptografia e controle de objetos gravados no bucket de resultados de consultas. As configurações do grupo de trabalho substituem todas as configurações do lado do cliente especificadas para uma consulta ao usar o console, as ações da API ou os drivers JDBC ou ODBC. Após as configurações do grupo de trabalho serem definidas como Substituir as configurações do lado do cliente, as configurações do lado do cliente nos drivers ou na API podem ser omitidas.
Se você substituir as configurações no lado do cliente, da próxima vez que você ou qualquer usuário do grupo de trabalho abrir o console do Athena, o Athena notificará você de que as consultas do grupo de trabalho usam as configurações do grupo de trabalho e solicitará a confirmação dessa alteração.
**nota**
Como a substituição das configurações do lado do cliente pode interromper a automação personalizada baseada na disponibilidade de resultados em um bucket arbitrário do Amazon S3, recomendamos que você informe a seus usuários antes de fazer a substituição.
**Importante**
Se você usar ações de API, a AWS CLI ou os drivers JDBC e ODBC para executar consultas em um grupo de trabalho que substitui as configurações do lado do cliente, omita as configurações do lado do cliente em suas consultas ou atualize-as para corresponder às configurações do grupo de trabalho.
Se você especificar configurações do lado do cliente nas consultas, mas executá-las em um grupo de trabalho que substitui as configurações, as consultas serão executadas, mas serão usadas as configurações do grupo de trabalho. Para obter informações sobre como visualizar as configurações de um grupo de trabalho, consulte [Visualizar os detalhes do grupo de trabalho](viewing-details-workgroups.md).
# Gerenciar grupos de trabalho
No console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home), você pode realizar as seguintes tarefas:
| Declaração | Descrição |
| --- | --- |
| [Criar um grupo de trabalho](creating-workgroups.md) | Criar um novo grupo de trabalho. |
| [Visualizar os detalhes do grupo de trabalho](viewing-details-workgroups.md) | Visualize os detalhes do grupo de trabalho, como nome, descrição, limites de uso de dados, localização de resultados de consultas, proprietário esperado do bucket de resultados de consultas, criptografia e controle de objetos gravados no bucket de resultados de consultas. Você também pode verificar se esse grupo de trabalho impõe suas configurações, caso a opção Override client-side settings (Substituir configurações no lado do cliente) esteja marcada. |
| [Especificar um grupo de trabalho para consultas](specify-wkgroup-to-athena-in-which-to-run-queries.md) | Antes de executar as consultas, especifique ao Athena qual grupo de trabalho deve ser usado. Você deve ter permissões para o grupo de trabalho. |
| [Alternar grupos de trabalho](switching-workgroups.md) | Alterne entre grupos de trabalho aos quais você tem acesso. |
| [Editar um grupo de trabalho](editing-workgroups.md) | Editar um grupo de trabalho e alterar as configurações. Você não pode alterar o nome de um grupo de trabalho, mas pode criar um novo grupo de trabalho com as mesmas configurações e um nome diferente. |
| [Habilitar ou desabilitar um grupo de trabalho](workgroups-enabled-disabled.md) | Habilite ou desabilite um grupo de trabalho. Quando um grupo de trabalho estiver desabilitado, os usuários não poderão executar consultas nem criar novas consultas com nome. Se você tiver acesso a ele, ainda pode visualizar métricas, os controles de limite de uso de dados, as configurações de grupo de trabalho, o histórico de consultas e as consultas salvas. |
| [Copiar uma consulta salva entre grupos de trabalho](copy-a-query-between-workgroups.md) | Copie uma consulta salva entre grupos de trabalho. Convém fazer isso se, por exemplo, você criou uma consulta em um grupo de trabalho de previsualização e quiser disponibilizá-la em um grupo de trabalho que não seja de previsualização. |
| [Excluir um grupo de trabalho](deleting-workgroups.md) | Exclua um grupo de trabalho. Se você excluir um grupo de trabalho, serão excluídos o histórico de consultas, as consultas salvas, as configurações do grupo de trabalho e os controles do limite de dados por consulta. Os controles do limite de dados no âmbito do grupo de trabalho permanecem no CloudWatch, e você pode excluí-los um a um. O grupo de trabalho principal não pode ser excluído. |
| [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md) | Use as políticas do IAM para controlar acesso dos grupos de trabalho. Para obter exemplos de políticas de grupo de trabalho, consulte [Exemplo de políticas de grupo de trabalho](example-policies-workgroup.md). |
| [Crie um grupo de trabalho do Athena que use a autenticação do Centro de Identidade do IAM](workgroups-identity-center.md) | Para usar as identidades do Centro de Identidade do IAM com o Athena, é necessário criar um grupo de trabalho habilitado para o Centro de Identidade do IAM. Após criar o grupo de trabalho, você poderá usar o console ou a API do Centro de Identidade do IAM para atribuir usuários ou grupos do Centro de Identidade do IAM ao grupo de trabalho. |
| [Configurar criptografia mínima para um grupo de trabalho](workgroups-minimum-encryption.md) | Imponha um nível mínimo de criptografia no Amazon S3 para todos os resultados de consultas do grupo de trabalho. Use esse atributo para garantir que os resultados de consulta nunca sejam armazenados em um bucket do Amazon S3 em estado não criptografado. |
# Visualizar os detalhes do grupo de trabalho
Para cada grupo de trabalho, você pode visualizar os detalhes. Os detalhes incluem o nome do grupo de trabalho, a descrição, se ele está habilitado ou desabilitado, e as configurações usadas para consultas executadas no grupo de trabalho, que incluem a localização dos resultados das consultas, o proprietário esperado do bucket, a criptografia e o controle de objetos gravados no bucket de resultados de consultas. Se um grupo de trabalho tiver limites de uso de dados, eles também serão exibidos.
**Para exibir os detalhes do grupo de trabalho**
1. No painel de navegação do console do Athena, escolha **Workgroups** (Grupos de trabalho).
1. Na página **Workgroups** (Grupos de trabalho), escolha o link do grupo de trabalho que você deseja visualizar. A página **Overview Details** (Visão geral dos detalhes) do grupo de trabalho é exibida.
# Especificar um grupo de trabalho para consultas
Para especificar um grupo de trabalho a ser usado, você deve ter permissões para ele.
**Para especificar o grupo de trabalho a usar**
1. Suas permissões devem permitir que você execute consultas no grupo de trabalho que você pretende usar. Para obter mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md).
1. Para especificar o grupo de trabalho, use uma destas opções:
+ Se você estiver acessando o Athena por meio do console, defina o grupo de trabalho [alternando os grupos de trabalho](switching-workgroups.md).
+ Se você usa as operações de API do Athena, especifique o nome do grupo de trabalho na ação da API. Por exemplo, você pode definir o nome do grupo de trabalho em [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html), da seguinte forma:
```
StartQueryExecutionRequest startQueryExecutionRequest = new StartQueryExecutionRequest()
.withQueryString(ExampleConstants.ATHENA_SAMPLE_QUERY)
.withQueryExecutionContext(queryExecutionContext)
.withWorkGroup(WorkgroupName)
```
+ Se você estiver usando o driver JDBC ou ODBC, defina o nome do grupo de trabalho na string de conexão usando o parâmetro de configuração `Workgroup`. O driver passa o nome do grupo de trabalho para o Athena. Especifique o parâmetro do grupo de trabalho na string de conexão, como no exemplo a seguir:
```
jdbc:awsathena://AwsRegion=;UID=;
PWD=;S3OutputLocation=s3://amzn-s3-demo-bucket/-/;
Workgroup=;
```
# Alternar grupos de trabalho
Você pode alternar de um grupo de trabalho para outro caso você tenha permissões para ambos.
Você pode abrir até dez guias de consulta dentro de cada grupo de trabalho. Quando alternar entre grupos de trabalho, suas guias de consulta permanecerão abertas para até três grupos de trabalho.
**Para alternar grupos de trabalho**
1. No console do Athena, escolha a opção **Workgroup** (Grupo de trabalho) no canto superior direito para escolher um grupo de trabalho.
1. Se a caixa de diálogo **Workgroup *workgroup-name* settings** (Configurações de nome-do-grupo-de-trabalho do grupo de trabalho) for exibida, escolha **Acknowledge** (Confirmar).
A opção **Workgroup** (Grupo de trabalho) mostra o nome do grupo de trabalho para o qual você mudou. Você já pode executar consultas nesse grupo de trabalho.
# Editar um grupo de trabalho
Como editar um grupo de trabalho requer permissões para operações da API `UpdateWorkgroup`. Consulte [Configurar o acesso a grupos de trabalho e tags](workgroups-access.md) e [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md). Se você adicionar ou editar tags, também precisará ter permissões para `TagResource`. Consulte [Exemplos de política de etiquetas para grupos de trabalho](tags-access-control.md#tag-policy-examples-workgroups).
**Para editar um grupo de trabalho no console**
1. No painel de navegação do console do Athena, escolha **Workgroups** (Grupos de trabalho).
1. Na página **Workgroups** (Grupos de trabalho), selecione o botão do grupo de trabalho que você deseja editar.
1. Selecione **Ações**, **Editar**.
1. Altere os campos conforme necessário. Para ver a lista de campos, consulte [Criar grupo de trabalho](creating-workgroups.md). Você pode alterar todos os campos, exceto pelo nome do grupo de trabalho. Se você precisar alterar o nome, crie outro grupo de trabalho com o novo nome e as mesmas configurações.
1. Escolha **Salvar alterações**. O grupo de trabalho atualizado aparece na lista na página **Workgroups** (Grupos de trabalho).
# Habilitar ou desabilitar um grupo de trabalho
Se você tiver permissões para fazê-lo, pode habilitar ou desabilitar grupos de trabalho no console usando as operações de API ou com os drivers JDBC e ODBC.
**Para habilitar ou desabilitar um grupo de trabalho**
1. No painel de navegação do console do Athena, escolha **Workgroups** (Grupos de trabalho).
1. Na página **Workgroups** (Grupos de trabalho), escolha o link do grupo de trabalho.
1. No canto superior direito, escolha **Enable workgroup** (Habilitar grupo de trabalho) ou **Disable workgroup** (Desativar grupo de trabalho).
1. No prompt de confirmação, escolha **Enable** (Habilitar) ou **Disable** (Desabilitar). Se você desativar um grupo de trabalho, os usuários não poderão executar consultas nem criar novas consultas nomeadas. Se você habilitar um grupo de trabalho, os usuários poderão usá-lo para executar consultas.
# Copiar uma consulta salva entre grupos de trabalho
Atualmente, o console do Athena não tem uma opção para copiar uma consulta salva de um grupo de trabalho para outro diretamente, mas você pode executar a mesma tarefa manualmente usando o procedimento a seguir.
**Para copiar uma consulta salva entre grupos de trabalho**
1. No console do Athena, no grupo de trabalho do qual você deseja copiar a consulta, escolha a guia **Saved queries** (Consultas salvas).
1. Escolha o link da consulta salva que você deseja copiar. O Athena abre a consulta no editor de consultas.
1. No editor de consultas, selecione o texto da consulta e pressione **Ctrl\$1C** para copiá-lo.
1. [Alterne](switching-workgroups.md) para o grupo de trabalho de destino ou [crie um grupo de trabalho](creating-workgroups.md) e alterne para ele.
1. Abra uma nova guia no editor de consultas e pressione **Ctrl\$1V** para colar o texto na nova guia.
1. No editor de consultas, escolha **Save as** (Salvar como) para salvar a consulta no grupo de trabalho de destino.
1. Na caixa de diálogo **Choose a name** (Escolher um nome), insira um nome para a consulta e uma descrição opcional.
1. Escolha **Salvar**.
# Excluir um grupo de trabalho
Você pode excluir um grupo de trabalho se tiver permissões para fazê-lo. O grupo de trabalho principal não pode ser excluído.
Se tiver permissões, você poderá excluir um grupo de trabalho vazio a qualquer momento. Você também pode excluir um grupo de trabalho que contém as consultas salvas. Nesse caso, antes de prosseguir para excluir um grupo de trabalho, o Athena avisa que as consultas salvas serão excluídas.
Se você excluir um grupo de trabalho enquanto estiver nele, o console vai alternar o foco para o grupo de trabalho principal. Se você tiver acesso a ele, pode executar consultas e exibir as configurações.
Se você excluir um grupo de trabalho, as configurações e os controles de limite de dados por consulta serão excluídos. Os controles de limite de dados no âmbito do grupo de trabalho permanecem no CloudWatch, e você pode excluí-los, se necessário.
**Importante**
Antes de excluir um grupo de trabalho, verifique se os usuários também pertencem a outros grupos de trabalho onde podem continuar a executar consultas. Se as políticas do IAM dos usuários permitirem que eles executem consultas *somente* nesse grupo de trabalho e você o excluir, eles não terão mais permissões para executar as consultas. Para obter mais informações, consulte [Example policy for running queries in the primary workgroup](example-policies-workgroup.md#example4-run-in-primary-access).
**Para excluir um grupo de trabalho no console**
1. No painel de navegação do console do Athena, escolha **Workgroups** (Grupos de trabalho).
1. Na página **Workgroups** (Grupos de trabalho), selecione o botão do grupo de trabalho que você deseja excluir.
1. Selecione **Ações**, **Excluir**.
1. No prompt de confirmação, insira **Delete workgroup** (Excluir grupo de trabalho) insira o nome do grupo de trabalho e, em seguida, escolha **Delete** (Excluir).
Para excluir um grupo de trabalho com a operação da API, use a ação `DeleteWorkGroup`.
# Usar o CloudWatch e o EventBridge para monitorar as consultas e controlar os custos
Os grupos de trabalho permitem que você defina os limites de controle de uso de dados por consulta ou por grupo de trabalho, configure alarmes quando esses limites são excedidos e publique métricas de consultas no CloudWatch.
Em cada grupo de trabalho, você pode:
+ Configurar os **Data usage controls (Controles de uso de dados)** por consulta e por grupo de trabalho e estabelecer ações que serão executadas se as consultas violarem os limites.
+ Visualizar e analisar as métricas de consulta e publicá-las no CloudWatch. Se você criar um grupo de trabalho no console, a configuração para publicação das métricas no CloudWatch será selecionada para você. Se você usar as operações de API, deve [habilitar a publicação de métricas](athena-cloudwatch-metrics-enable.md). Quando são publicadas, as métricas são exibidas na guia **Metrics (Métricas)** do painel **Workgroups (Grupos de trabalho)**. As métricas são desativadas por padrão para o grupo de trabalho principal.
## Vídeo
O vídeo a seguir mostra como criar painéis personalizados e definir alarmes e acionadores com base nas métricas no CloudWatch. Você pode usar painéis pré-preenchidos diretamente do console do Athena para consumir essas métricas de consulta.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/x1V_lhkdKCg)
**Topics**
+ [
## Vídeo
](#athena-cloudwatch-metrics-video)
+ [Habilitar métricas de consultas](athena-cloudwatch-metrics-enable.md)
+ [Monitorar métricas de consultas com o CloudWatch](query-metrics-viewing.md)
+ [Monitorar métricas de uso com o CloudWatch](monitoring-athena-usage-metrics.md)
+ [Monitorar eventos de consulta com o EventBridge](athena-events.md)
+ [Configurar controles de uso de dados](workgroups-setting-control-limits-cloudwatch.md)
# Habilitar métricas de consultas do CloudWatch no Athena
Ao criar um grupo de trabalho no console, será selecionada por padrão a configuração para publicar as métricas de consulta no CloudWatch.
**Para habilitar ou desabilitar as métricas de consulta no console do Athena para um grupo de trabalho**
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 **Global networks** (Redes globais).
1. Escolha o link do grupo de trabalho que você deseja modificar.
1. Na página de detalhes do grupo de trabalho, escolha **Edit** (Editar).
1. Na seção **Configurações**, marque ou desmarque **Publicar métricas de consulta no AWS CloudWatch**.
Se você usar operações de API, a interface de linha de comando ou o aplicativo cliente com o driver JDBC para criar grupos de trabalho, de forma a habilitar a publicação de métricas de consulta, defina `PublishCloudWatchMetricsEnabled` como `true` em [WorkGroupConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_WorkGroupConfiguration.html). O exemplo a seguir mostra apenas a configuração das métricas e omite outra configuração:
```
"WorkGroupConfiguration": {
"PublishCloudWatchMetricsEnabled": "true"
....
}
```
# Monitorar métricas de consultas do Athena com o CloudWatch
O Athena publica as métricas relacionadas à consulta no Amazon CloudWatch, quando a opção [Publish query metrics to CloudWatch](athena-cloudwatch-metrics-enable.md) (Publicar métricas de consulta no CloudWatch) está selecionada. Você pode criar painéis personalizados, definir alarmes e acionadores com base nas métricas no CloudWatch ou usar painéis pré-preenchidos diretamente no console do Athena.
Quando você habilitar as métricas de consulta nos grupos de trabalho, elas serão exibidas na guia **Metrics** (Métricas) do painel **Workgroups** (Grupos de trabalho) para cada grupo de trabalho do console do Athena.
O Athena publica as seguintes métricas no console do CloudWatch:
+ `DPUAllocated`: o número total de DPUs (unidades de processamento de dados) provisionadas em uma reserva de capacidade para executar consultas.
+ `DPUConsumed`: o número de DPUs consumidas ativamente por consultas em um estado de `RUNNING` em um dado momento em uma reserva. Métrica emitida somente quando o grupo de trabalho está associado a uma reserva de capacidade e inclui todos os grupos de trabalho associados a uma reserva.
+ `DPUCount`: o número máximo de DPUs consumidas pela consulta, publicado exatamente uma vez quando a consulta é concluída.
+ `EngineExecutionTime`: o número de milissegundos que a consulta levou para ser executada.
+ `ProcessedBytes`: o número de bytes verificados pelo Athena por consulta DML.
+ `QueryPlanningTime`: o número de milissegundos que o Athena levou para planejar o fluxo de processamento da consulta.
+ `QueryQueueTime`: o número de milissegundos que a consulta ficou na fila de consultas aguardando recursos.
+ `ServicePreProcessingTime`: o número de milissegundos que o Athena levou para pré-processar a consulta antes de enviá-la para o mecanismo de consulta.
+ `ServiceProcessingTime`: o número de milissegundos que o Athena levou para processar os resultados da consulta depois que o mecanismo de consulta concluiu sua execução.
+ `TotalExecutionTime`: o número de milissegundos que o Athena levou para executar uma consulta DDL ou DML.
Para obter descrições mais completas, consulte [Lista de métricas e dimensões do CloudWatch para o Athena](#athena-cloudwatch-metrics-table) mais adiante neste documento.
Essas métricas têm as seguintes dimensões:
+ `CapacityReservation`: o nome da reserva de capacidade usada para executar a consulta, se aplicável.
+ `QueryState` – `SUCCEEDED`, `FAILED`, ou `CANCELED`
+ `QueryType` – `DML`, `DDL`, ou `UTILITY`
+ `WorkGroup`: nome do grupo de trabalho
O Athena publica a seguinte métrica no console do CloudWatch sob o namespace `AmazonAthenaForApacheSpark`:
+ `DPUCount`: a quantidade de DPUs consumidas durante a sessão para executar os cálculos.
Essa métrica tem as seguintes dimensões:
+ `SessionId`: o ID da sessão para a qual os cálculos são enviados.
+ `WorkGroup`: o nome do grupo de trabalho.
Para obter mais informações, consulte [Lista de métricas e dimensões do CloudWatch para o Athena](#athena-cloudwatch-metrics-table) posteriormente neste tópico. Para obter mais informações as métricas de uso do Athena, consulte [Monitorar métricas de uso do Athena com o CloudWatch](monitoring-athena-usage-metrics.md).
Você pode visualizar as métricas de consultas no console do Athena ou no console do CloudWatch.
## Visualizar métricas de consultas no console do Athena
**Para visualizar as métricas de consultas para um grupo de trabalho 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 **Global networks** (Redes globais).
1. Escolha o grupo de trabalho que você deseja na lista e escolha a guia **Metrics** (Métricas).
O painel de métricas é exibido.
**nota**
Se você ativou recentemente métricas para o grupo de trabalho e/ou não houve nenhuma atividade de consulta recente, os gráficos no painel poderão ficar vazios. A atividade de consulta é recuperada do CloudWatch dependendo do intervalo especificado na próxima etapa.
1. Na seção **Metrics** (Métricas), escolha o intervalo de métricas que o Athena deve usar para buscar as métricas de consulta do CloudWatch ou especifique um intervalo personalizado.
![\[Especificar o intervalo de recuperação de métricas para um grupo de trabalho no console do Athena.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/wg-custom-interval.png)
1. Para atualizar as métricas exibidas, escolha o ícone de atualização.
![\[Escolha o ícone de atualização.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/wg-refresh-metrics.png)
1. Clique na seta ao lado do ícone de atualização para escolher com que frequência você deseja que a exibição de métricas seja atualizada.
![\[Escolher um intervalo de atualização para a exibição das métricas do grupo de trabalho no console do Athena.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/wg-choose-refresh-interval.png)
## Visualizar métricas de consultas no console do CloudWatch
**Para visualizar as métricas no console do Amazon CloudWatch**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **All metrics** (Todas as métricas).
1. Selecione o namespace **AWS/Athena**.
## Visualizar métricas de consultas com a AWS CLI
**Para visualizar métricas com a AWS CLI**
+ Execute um destes procedimentos:
+ Para listar as métricas do Athena, abra um prompt de comando e use o seguinte comando:
```
aws cloudwatch list-metrics --namespace "AWS/Athena"
```
+ Para listar todas as métricas disponíveis, use o comando a seguir:
```
aws cloudwatch list-metrics"
```
## Lista de métricas e dimensões do CloudWatch para o Athena
Se você habilitou as métricas do CloudWatch no Athena, ele enviará as métricas a seguir ao CloudWatch por grupo de trabalho. As métricas a seguir usam o namespace `AWS/Athena`.
| Nome da métrica | Descrição |
| --- | --- |
| DPUAllocated | O número total de DPUs (unidades de processamento de dados) provisionadas em uma reserva de capacidade para executar consultas. |
| DPUConsumed | O número de DPUs consumidas ativamente por consultas em um estado de RUNNING em um dado momento em uma reserva. Essa métrica só é emitida quando o grupo de trabalho está associado a uma reserva de capacidade e inclui todos os grupos de trabalho associados a uma reserva. Se você mover um grupo de trabalho de uma reserva para outra, a métrica incluirá dados de quando o grupo de trabalho pertencia à primeira reserva. Para obter mais informações sobre reservas de capacidade, consulte [Gerenciar a capacidade de processamento de consulta](capacity-management.md). |
| DPUCount | O número máximo de DPUs consumidas pela consulta, publicado exatamente uma vez quando a consulta é concluída. Essa métrica só é emitida para grupos de trabalho associados a uma reserva de capacidade. |
| EngineExecutionTime | O número de milissegundos que a consulta levou para ser executada. |
| ProcessedBytes | O número de bytes verificados pelo Athena para cada consulta DML. Para consultas que foram canceladas (pelo usuários, ou automaticamente, se atingiram o limite), isso inclui a quantidade de dados verificada antes da hora do cancelamento. Essa métrica não é relatada para consultas DDL. |
| QueryPlanningTime | O número de milissegundos que o Athena levou para planejar o fluxo de processamento da consulta. Isso inclui o tempo gasto recuperando partições de tabela da fonte de dados. Observe que, como o mecanismo de consulta executa o planejamento da consulta, o tempo de planejamento de consulta é um subconjunto de EngineExecutionTime. |
| QueryQueueTime | O número de milissegundos que a consulta estava na fila de consultas aguardando recursos. Observe que, se ocorrerem erros temporários, a consulta poderá ser adicionada automaticamente de volta à fila. |
| ServicePreProcessingTime | O número de milissegundos que o Athena levou para pré-processar a consulta antes de enviá-la para o mecanismo de consulta. |
| ServiceProcessingTime | O número de milissegundos que o Athena levou para processar os resultados da consulta depois que o mecanismo de consulta concluiu a execução da consulta. |
| TotalExecutionTime | O número de milissegundos que o Athena levou para executar uma consulta DDL ou DML. TotalExecutionTime inclui QueryQueueTime, QueryPlanningTime, EngineExecutionTime e ServiceProcessingTime. |
Essas métricas do Athena têm as dimensões a seguir.
| Dimensão | Descrição |
| --- | --- |
| CapacityReservation | O nome da reserva de capacidade usada para executar a consulta, se aplicável. Quando uma reserva de capacidade não é usada, essa dimensão não retorna nenhum dado. |
| QueryState | O estado da consulta. Estatísticas válidas: SUCCEEDED, FAILED ou CANCELED. |
| QueryType | O tipo de consulta. Estatísticas válidas: `DDL`, `DML` ou `UTILITY`. O tipo de instrução de consulta que foi executada. `DDL` indica instruções de consulta DDL (Data Definition Language). `DML` indica instruções de consulta DML (Data Manipulation Language), como `CREATE TABLE AS SELECT`. `UTILITY` indica instruções de consulta diferentes de DDL e DML, como `SHOW CREATE TABLE` ou `DESCRIBE TABLE`. |
| WorkGroup | O nome do grupo de trabalho. |
# Monitorar métricas de uso do Athena com o CloudWatch
Você pode usar as métricas de uso do CloudWatch para fornecer visibilidade de como a conta usa os recursos, exibindo o uso do serviço atual nos gráficos e painéis do CloudWatch.
Para o Athena, as métricas de disponibilidade para uso correspondem às cotas de AWS service (Serviço da AWS) para o Athena. Também é possível configurar alarmes que alertem você quando o uso se aproximar de uma cota de serviço. Para obter mais informações sobre cotas de serviço do Athena, consulte [Service Quotas](service-limits.md). Para obter mais informações sobre métricas de uso do AWS, consulte [ métricas de uso da AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Service-Quota-Integration.html) no *Guia do usuário do Amazon CloudWatch*.
O Athena publica as métricas a seguir no namespace `AWS/Usage`.
| Nome da métrica | Descrição |
| --- | --- |
| `ResourceCount` | A soma de todas as consultas enfileiradas e em execução por Região da AWS por conta, separada por tipo de consulta (DML ou DDL). O máximo é a única estatística útil para essa métrica. Essa métrica é publicada periodicamente, a cada minuto. Se você não estiver executando nenhuma consulta, a métrica não reportará nada (nem mesmo 0). A métrica será publicada somente se as consultas ativas estiverem sendo executadas no momento em que a métrica é verificada. |
As dimensões a seguir são usadas para refinar as métricas de uso publicadas pelo Athena..
| Dimensão | Descrição |
| --- | --- |
| `Service` | O nome do AWS service (Serviço da AWS) que contém o recurso. Para o Athena, o valor dessa dimensão é `Athena`. |
| `Resource` | O tipo de recurso que está em execução. O valor de recurso para o uso de consulta do Athena é `ActiveQueryCount`. |
| `Type` | O tipo de entidade que está sendo relatada. Atualmente, o único valor válido para métricas de uso do Athena é `Resource`. |
| `Class` | A classe do recurso sob acompanhamento. Para o Athena, `Class` pode ser um `DML` ou um `DDL`. |
## Visualizar métricas de uso de recursos do Athena no console do CloudWatch
Você pode usar o console do CloudWatch para ver um gráfico das métricas de uso do Athena e configurar alarmes que o alertarão quando o uso se aproximar de uma cota de serviço.
**Para ver as métricas de uso dos recursos do Athena**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **All metrics** (Todas as métricas).
1. Escolha **Uso** e depois **Por recurso da AWS**.
A lista das métricas de uso da cota de serviço é exibida.
1. Marque a caixa de seleção ao lado de **Athena** e **ActiveQueryCount**.
1. Escolha a guia **Graphed metrics (Métricas em gráfico)**.
O gráfico acima exibe o uso atual do recurso da AWS.
Para obter informações sobre como adicionar cotas de serviço ao grafo e definir um alarme que notifique você caso o uso se aproxime da cota de serviço, consulte [Visualizar cotas de serviço e definir alarmes](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Quotas-Visualize-Alarms.html) no *Guia do usuário do Amazon CloudWatch*. Para obter informações sobre como definir limites de uso por grupo de trabalho, consulte [Configurar controles de uso de dados por consulta e por grupo de trabalho](workgroups-setting-control-limits-cloudwatch.md).
# Monitorar eventos de consulta do Athena com o EventBridge
Você pode usar o Amazon Athena com o Amazon EventBridge para receber notificações em tempo real sobre o estado das consultas. Quando uma consulta enviada muda de estado, o Athena publica um evento no EventBridge com informações sobre a transição de estado da consulta. É possível gravar regras simples para eventos do seu interesse e realizar ações automatizadas quando um evento corresponder a uma regra. Por exemplo, é possível criar uma regra que invoca uma função do AWS Lambda quando uma consulta atinge um estado terminal. Os eventos são emitidos com base no melhor esforço.
Antes de criar regras de eventos para o Athena, faça o seguinte:
+ Familiarize-se com os eventos, regras e destinos no EventBridge. Para obter mais informações, consulte [O que é o Amazon EventBridge?](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) Para obter mais informações sobre a configuração de regras, consulte [Getting started with Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html).
+ Crie os destinos para usar em suas regras de evento.
**nota**
Atualmente, o Athena oferece um tipo de evento, a alteração de estado da consulta do Athena, mas pode adicionar outros tipos de eventos e detalhes. Caso você esteja desserializando programaticamente dados JSON do evento, certifique-se de que a aplicação esteja preparada para lidar com propriedades desconhecidas caso propriedades adicionais sejam incluídas.
## Formato de eventos do Athena
O item a seguir é o padrão básico de um evento do Amazon Athena.
```
{
"source":[
"aws.athena"
],
"detail-type":[
"Athena Query State Change"
],
"detail":{
"currentState":[
"SUCCEEDED"
]
}
}
```
## Evento de alteração de estado da consulta do Athena
O exemplo a seguir mostra um evento de alteração de estado da consulta do Athena com o valor `currentState` de `SUCCEEDED`.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Athena Query State Change",
"source":"aws.athena",
"account":"123456789012",
"time":"2019-10-06T09:30:10Z",
"region":"us-east-1",
"resources":[
],
"detail":{
"versionId":"0",
"currentState":"SUCCEEDED",
"previousState":"RUNNING",
"statementType":"DDL",
"queryExecutionId":"01234567-0123-0123-0123-012345678901",
"workgroupName":"primary",
"sequenceNumber":"3"
}
}
```
O exemplo a seguir mostra um evento de alteração de estado da consulta do Athena com o valor `currentState` de `FAILED`. O bloco `athenaError` aparece somente quando `currentState` corresponde a `FAILED`. Para obter informações sobre os valores de `errorCategory` e `errorType`, consulte [Catálogo de erros do Athena](error-reference.md).
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Athena Query State Change",
"source":"aws.athena",
"account":"123456789012",
"time":"2019-10-06T09:30:10Z",
"region":"us-east-1",
"resources":[
],
"detail":{
"athenaError": {
"errorCategory": 2.0, //Value depends on nature of exception
"errorType": 1306.0, //Type depends on nature of exception
"errorMessage": "Amazon S3 bucket not found", //Message depends on nature of exception
"retryable":false //Retryable value depends on nature of exception
},
"versionId":"0",
"currentState": "FAILED",
"previousState": "RUNNING",
"statementType":"DML",
"queryExecutionId":"01234567-0123-0123-0123-012345678901",
"workgroupName":"primary",
"sequenceNumber":"3"
}
}
```
### Propriedades de saída
A saída JSON inclui as seguintes propriedades.
****
| Propriedade | Descrição |
| --- | --- |
| athenaError | Aparece somente quando currentState corresponde a FAILED. Contém informações sobre o erro ocorrido, incluindo a categoria do erro, o tipo de erro, a mensagem de erro e se a ação que levou ao erro pode ocorrer novamente. Os valores para cada um desses campos dependem da natureza do erro. Para obter informações sobre os valores de errorCategory e errorType, consulte [Catálogo de erros do Athena](error-reference.md). |
| versionId | O número da versão do esquema do objeto de detalhes. |
| currentState | O estado para o qual a consulta foi alterada no momento do evento. |
| previousState | O estado inicial da consulta no momento do evento. |
| statementType | O tipo de instrução da consulta executada. |
| queryExecutionId | O identificador exclusivo da execução da consulta. |
| workgroupName | O nome do grupo de trabalho no qual a consulta foi executada. |
| sequenceNumber | Um número continuamente crescente que permite a eliminação de duplicação e classificação de eventos de entrada que envolvem uma única execução de consulta. Quando eventos duplicados forem publicados para a mesma transição de estado, o valor sequenceNumber será o mesmo. Quando uma consulta apresentar mais de uma transição de estado, como consultas que apresentam raro reenfileiramento, é possível usar sequenceNumber para classificar eventos com valores idênticos de currentState e previousState. |
## Exemplo
O exemplo a seguir publica eventos em um tópico do Amazon SNS ao qual você se inscreveu. Quando o Athena é consultado, você recebe um e-mail. O exemplo pressupõe que o tópico do Amazon SNS existe e que você está inscrito nele.
**Para publicar eventos do Athena em um tópico do Amazon SNS**
1. Crie um destino para o tópico do Amazon SNS. Conceda a permissão `events.amazonaws.com` à entidade principal do serviço de eventos do EventBridge para publicar no tópico do Amazon SNS, como no exemplo a seguir.
```
{
"Effect":"Allow",
"Principal":{
"Service":"events.amazonaws.com"
},
"Action":"sns:Publish",
"Resource":"arn:aws:sns:us-east-1:111111111111:your-sns-topic"
}
```
1. Use o comando da AWS CLI `events put-rule` para criar uma regra para eventos do Athena, como no exemplo a seguir.
```
aws events put-rule --name {ruleName} --event-pattern '{"source": ["aws.athena"]}'
```
1. Use o comando da AWS CLI `events put-targets` para anexar o destino do tópico do Amazon SNS à regra, conforme o exemplo a seguir.
```
aws events put-targets --rule {ruleName} --targets Id=1,Arn=arn:aws:sns:us-east-1:111111111111:your-sns-topic
```
1. Consulte o Athena e observe o destino sendo invocado. Você receberá e-mails correspondentes do tópico do Amazon SNS.
## Usar o Notificações de Usuários da AWS com o Amazon Athena
É possível usar o [Notificações de Usuários da AWS](https://docs.aws.amazon.com/notifications/latest/userguide/what-is.html) para configurar canais de entrega para receber notificações sobre eventos do Amazon Athena. Você recebe uma notificação quando um evento corresponde a uma regra especificada. É possível receber notificações para eventos por meio de diversos canais, incluindo o e-mail, o [Amazon Q Developer em aplicações de chat](https://docs.aws.amazon.com/chatbot/latest/adminguide/what-is.html), notificações por chat ou notificações push do [AWS Console Mobile Application](https://docs.aws.amazon.com/consolemobileapp/latest/userguide/what-is-consolemobileapp.html). Você também pode visualizar notificações na [Central de Notificações do Console](https://console.aws.amazon.com/notifications/). O Notificações de Usuários oferece é compatível com agregação, o que pode reduzir o número de notificações que você recebe durante eventos específicos.
Para saber mais, consulte o [https://docs.aws.amazon.com/notifications/latest/userguide/what-is.html](https://docs.aws.amazon.com/notifications/latest/userguide/what-is.html).
# Configurar controles de uso de dados por consulta e por grupo de trabalho
O Athena permite a definição de dois tipos de controles de custo: limite por consulta e limite por grupo de trabalho. Para cada grupo de trabalho, você só pode definir um limite por consulta e vários limites por grupo de trabalho.
+ O **limite de controle por consulta** especifica a quantidade total de dados analisados por consulta. Se qualquer consulta que for executada no grupo de trabalho exceder o limite, ela será cancelada. Você pode criar apenas um limite de controle por consulta em um grupo de trabalho e aplicá-lo a cada consulta que for executada nele. Edite o limite se precisar alterá-lo. Para obter etapas detalhadas, consulte [Para criar um controle de uso de dados por consulta](#configure-control-limit-per-query).
+ O **limite de controle de uso de dados no âmbito do grupo de trabalho** especifica a quantidade total de dados verificados para todas as consultas que são executadas neste grupo de trabalho durante o período especificado. Você pode criar vários limites por grupo de trabalho. O limite de consulta no âmbito do grupo de trabalho permite que você defina vários limites em agregados de hora e dia nos dados analisados por consultas em execução no grupo de trabalho.
Se a quantidade somada de dados verificados exceder o limite, você poderá enviar uma notificação para um tópico do Amazon SNS. Para fazer isso, configure um alarme do Amazon SNS e uma ação no console do Athena para notificar um administrador quando o limite for violado. Para obter etapas detalhadas, consulte [Para criar um controle de uso de dados por grupo de trabalho](#configure-control-limit-per-workgroup). Você também pode criar um alarme e uma ação com base em qualquer métrica que o Athena publicar pelo console do CloudWatch. Por exemplo, você pode configurar um alerta para um determinado número de consultas com falha. Esse alerta pode acionar um e-mail para um administrador se o número ultrapassar um determinado limite. Se o limite for excedido, uma ação enviará uma notificação de alarme do Amazon SNS aos usuários especificados.
Outras ações que você pode executar:
+ Invocar uma função do Lambda. Para obter mais informações, consulte [Invocar funções do Lambda usando notificações do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-lambda-as-subscriber.html) no *Guia do desenvolvedor do Amazon Simple Notification Service*.
+ Desabilite o grupo de trabalho para interromper a execução de outras consultas. Para obter as etapas, consulte [Habilitar ou desabilitar um grupo de trabalho](workgroups-enabled-disabled.md).
Os limites por consulta e por grupo de trabalho são independentes um do outro. Uma ação especificada será executada sempre que o limite for excedido. Se dois ou mais usuários executarem consultas ao mesmo tempo no mesmo grupo de trabalho, é possível que cada consulta não exceda nenhum dos limites especificados, mas a soma dos dados verificados exceda o limite de uso de dados por grupo de trabalho. Nesse caso, um alarme do Amazon SNS será enviado ao usuário.
## Criar um controle de uso de dados por consulta
**Para criar um controle de uso de dados por consulta**
O limite de controle por consulta especifica a quantidade total de dados analisados por consulta. Se qualquer consulta que for executada no grupo de trabalho exceder o limite, ela será cancelada. As consultas canceladas são cobradas de acordo com os [Preços do Amazon Athena](https://aws.amazon.com/athena/pricing/).
**nota**
No caso de consultas canceladas ou com falha, o Athena pode já ter gravado resultados parciais no Amazon S3. Nesses casos, o Athena não excluirá os resultados parciais do prefixo do Amazon S3 em que os resultados são armazenados. Você deve remover o prefixo do Amazon S3 com os resultados parciais. O Athena usa carregamentos fracionados do Amazon S3 para gravar dados do Amazon S3. Recomendamos que você defina a política de ciclo de vida do bucket para encerrar os carregamentos fracionados nos casos em que as consultas falharem. Para obter mais informações, consulte [Interromper um multipart upload incompleto usando uma política de ciclo de vida de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config) no *Guia do usuário do Amazon Simple Storage Service*.
Em certas condições, o Athena pode repetir automaticamente as execuções de consultas. Na maioria dos casos, essas consultas podem ser concluídas com êxito e o ID da consulta é marcado como `Completed`. É possível que essas consultas tenham gravado resultados parciais durante as primeiras tentativas e que gerem uploads incompletos de várias partes.
Você pode criar apenas um limite de controle por consulta em um grupo de trabalho e aplicá-lo a cada consulta que for executada nele. Edite o limite se precisar alterá-lo.
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 **Global networks** (Redes globais).
1. Escolha o nome do grupo de trabalho na lista.
1. Na guia **Controles de execução**, escolha **Editar controles**.
1. Edite o valor de **Limite de dados verificados**.
+ Especifique um valor entre 10 MB (mínimo) e 7 EB (máximo).
+ Selecione o valor unitário na lista suspensa (por exemplo, **Kilobytes KB** ou **Exabytes EB**).
**nota**
A ação padrão é cancelar a consulta se ela exceder o limite. Essa configuração não pode ser alterada.
1. Escolha **Salvar** para aplicar as alterações imediatamente.
## Criar ou editar um alerta de uso de dados por grupo de trabalho
**Para criar ou editar um alerta de uso de dados por grupo de trabalho**
Você pode definir vários limites de alerta quando as consultas em execução em um grupo de trabalho verificam uma quantidade especificada de dados dentro de um período específico. Os alertas são implementados usando alarmes do Amazon CloudWatch e se aplicam a todas as consultas no grupo de trabalho. Quando um limite é atingido, você pode fazer com que o Amazon SNS envie um e-mail aos usuários que você especificar. As consultas não são canceladas automaticamente quando um limite é atingido.
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.
1. No painel de navegação, escolha **Global networks** (Redes globais).
1. Escolha o nome do grupo de trabalho na lista.
1. Selecione **Edit** (Editar) para editar as configurações do grupo de trabalho.
1. Role para baixo até **Workgroup data usage alerts - optional** (Alertas de uso de dados do grupo de trabalho - opcional) e expanda essa opção.
1. Escolha **Add alert** (Adicionar alerta).
1. Em **Data usage threshold configuration** (Configuração de limite de uso de dados), especifique os valores da maneira a seguir:
+ Em **Data threshold** (Limite de dados), especifique um número e, em seguida, selecione um valor unitário na lista suspensa.
+ Em **Time period** (Período), escolha um período na lista suspensa.
+ Em **SNS topic selection** (Seleção de tópico do SNS), escolha um tópico do Amazon SNS na lista suspensa. Se preferir, escolha **Create an SNS topic** (Criar um tópico do SNS) para acessar diretamente o [console do Amazon SNS](https://console.aws.amazon.com/sns/v2/home), crie o tópico do Amazon SNS e configure uma assinatura para ele para um dos usuários em sua conta do Athena. Para obter mais informações, consulte [Conceitos básicos do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html) no *Guia do desenvolvedor do Amazon Simple Notification Service*.
1. Escolha **Add alert** (Adicionar alerta) se estiver criando um alerta ou **Save** (Salvar) para salvar um alerta existente.
# Usar APIs de grupos de trabalho do Athena
Veja a seguir algumas das operações de API REST usadas para os grupos de trabalho Athena. Em todas as operações a seguir, com exceção de `ListWorkGroups`, você deve especificar um grupo de trabalho. Em outras operações, como `StartQueryExecution`, o parâmetro do grupo de trabalho é opcional e as operações não estão listadas aqui. Para obter uma lista de operações, consulte a [Referência de API do Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).
+ [CreateWorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateWorkGroup.html)
+ [DeleteWorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteWorkGroup.html)
+ [GetWorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetWorkGroup.html)
+ [ListWorkGroups](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListWorkGroups.html)
+ [UpdateWorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateWorkGroup.html)
# Solucionar erros de grupo de trabalho
Use as dicas a seguir para solucionar problemas com grupos de trabalho.
+ Verifique as permissões para usuários individuais na sua conta. Eles devem ter acesso ao local para os resultados da consulta e ao grupo de trabalho no qual desejam executar consultas. Se eles quiserem alternar grupos de trabalho, vão precisar de permissões para ambos os grupos de trabalho. Para mais informações, consulte [Usar políticas do IAM para controlar o acesso de grupo de trabalho](workgroups-iam-policy.md).
+ Observe o contexto no console do Athena para ver em qual grupo de trabalho você vai executar as consultas. Se você usar o driver, defina o grupo de trabalho naquele de que você precisa. Para mais informações, consulte [Especificar um grupo de trabalho para consultas](specify-wkgroup-to-athena-in-which-to-run-queries.md).
+ Se você usar a API ou os drivers para executar as consultas, deverá especificar o local dos resultados das consultas usando uma destas formas: para consultas individuais, use [OutputLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_ResultConfiguration.html#athena-Type-ResultConfiguration-OutputLocation) (do lado do cliente). No grupo de trabalho, use [WorkGroupConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_WorkGroupConfiguration.html). Se o local não estiver especificado de nenhuma forma, o Athena emitirá um erro no runtime da consulta.
+ Se você substituir as configurações do lado do cliente pelas configurações do grupo de trabalho, poderá encontrar erros com o local de resultados da consulta. Por exemplo, um usuário do grupo de trabalho pode não ter permissões para o local do grupo de trabalho no Amazon S3 para armazenar os resultados das consultas. Nesse caso, adicione as permissões necessárias.
+ Os grupos de trabalho trazem mudanças no comportamento das operações da API. As chamadas para as operações de API existentes a seguir exigem que os usuários em sua conta tenham permissões baseadas em recursos no IAM para os grupos de trabalho em que são criados. Se não houver permissões para o grupo de trabalho e para as ações do grupo de trabalho, as seguintes ações da API ativarão `AccessDeniedException`: **CreateNamedQuery**, **DeleteNamedQuery**, **GetNamedQuery**, **ListNamedQueries**, **StartQueryExecution**, **StopQueryExecution**, **ListQueryExecutions**, **GetQueryExecution**, **GetQueryResults** e **GetQueryResultsStream** (essa ação de API está disponível somente para uso com o driver e não fica exposta para uso público). 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*.
As chamadas para as operações de API **BatchGetQueryExecution** e **BatchGetNamedQuery** retornam informações apenas sobre as execuções de consulta nos grupos de trabalho aos quais os usuários têm acesso. Se o usuário não tiver acesso ao grupo de trabalho, essas operações da API retornarão os IDs de consulta não autorizados como parte da lista de IDs não processados. Para obter mais informações, consulte [Usar APIs de grupos de trabalho do Athena](workgroups-api-list.md).
+ Se o grupo de trabalho em que uma consulta for executada estiver configurado com um [local imposto para os resultados das consultas](workgroups-settings-override.md), não especifique um `external_location` para a consulta CTAS. O Athena emite um erro e falha com uma consulta que especifica um `external_location` nesse caso. Por exemplo, ocorrerá uma falha nesta consulta se você substituir as configurações do lado do cliente para o local dos resultados da consulta, forçando o grupo de trabalho a usar o próprio local: `CREATE TABLE . WITH (format='Parquet', external_location='s3://amzn-s3-demo-bucket/test/') AS SELECT * FROM . LIMIT 10;`
Você pode ver os erros a seguir. Esta tabela fornece uma lista de alguns dos erros relacionados a grupos de trabalho e sugere soluções.
**Erros do grupo de trabalho**
| Erro | Ocorre quando... |
| --- | --- |
| query state CANCELED. Bytes scanned limit was exceeded. (o estado da consulta é CANCELED. O limite de bytes verificados foi excedido. | Uma consulta atinge um limite de dados por consulta e é cancelada. Considere reescrever a consulta para que leia menos dados ou entre em contato com o administrador da conta. |
| User: arn:aws:iam::123456789012:user/abc is not authorized to perform: athena:StartQueryExecution on resource: arn:aws:athena:us-east-1:123456789012:workgroup/workgroupname (O usuário: arn:aws:iam::123456789012:user/abc não está autorizado a executar: athena:StartQueryExecution no recurso: arn:aws:athena:us-east-1:123456789012:workgroup/workgroupname) | Um usuário executa uma consulta em um grupo de trabalho, mas não tem acesso a ele. Atualize a política para ter acesso ao grupo de trabalho. |
| INVALID\$1INPUT. WorkGroup is disabled. (INVALID\$1INPUT. O grupo de trabalho está desabilitado. | Um usuário executa uma consulta em um grupo de trabalho, mas o grupo de trabalho está desabilitado. Seu grupo de trabalho poderia ser desabilitado pelo administrador. É possível também que você não tenha acesso a ele. Em ambos os casos, entre em contato com um administrador que tenha acesso para modificar grupos de trabalho. |
| INVALID\$1INPUT. WorkGroup is not found. (INVALID\$1INPUT. O grupo de trabalho não foi localizado. | Um usuário executa uma consulta em um grupo de trabalho, mas o grupo de trabalho não existe. Isso pode acontecer se o grupo de trabalho tiver sido excluído. Alterne para outro grupo de trabalho para executar a consulta. |
| InvalidRequestException: ao chamar a operação StartQueryExecution: nenhum local de saída fornecido. An output location is required either through the Workgroup result configuration setting or as an API input. (InvalidRequestException: ao chamar a operação StartQueryExecution: nenhum local de saída é fornecido. Um local de saída é necessário por meio da definição de configuração de resultados do grupo de trabalho ou como uma entrada de API. | Um usuário executa uma consulta com a API sem especificar o local dos resultados da consulta. Você deve definir o local de saída para resultados da consulta usando uma de duas formas: para consultas individuais, usando [OutputLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_ResultConfiguration.html#athena-Type-ResultConfiguration-OutputLocation) (no lado do cliente), ou, no grupo de trabalho, usando [WorkGroupConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_WorkGroupConfiguration.html). |
| The Create Table As Select query failed because it was submitted with an “external\$1location” property to an Athena Workgroup that enforces a centralized output location for all queries. Please remove the “external\$1location” property and resubmit the query. (A consulta “Create Table As Select” falhou porque foi enviada com uma propriedade “external\$1location” para um grupo de trabalho do Athena que impõe um local de saída centralizado para todas as consultas. Remova a propriedade “external\$1location” e reenvie a consulta. | Se o grupo de trabalho em que uma consulta for executada estiver configurado com um [local imposto para os resultados da consulta](workgroups-settings-override.md) e você especificar um external\$1location para a consulta do CTAS. Neste caso, remova o external\$1location e execute a consulta. |
| Cannot create prepared statement prepared\$1statement\$1name. The number of prepared statements in this workgroup exceeds the limit of 1000. (Não é possível criar a instrução preparada “prepare\$1statement\$1name”. O número de instruções preparadas neste grupo de trabalho excede o limite de mil 1000. | O grupo de trabalho contém mais do que o limite de mil instruções preparadas. Para resolver esse problema, use [DEALLOCATE PREPARE](sql-deallocate-prepare.md) para remover uma ou mais instruções preparadas do grupo de trabalho. Como alternativa, crie um novo grupo de trabalho. |
# Gerenciar a capacidade de processamento de consulta
Você pode usar as reservas de capacidade para obter capacidade dedicada de processamento sem servidor para as consultas que você executa no Athena. Com as reservas de capacidade, você pode aproveitar os recursos de gerenciamento de workloads que ajudam a priorizar, controlar e escalar suas workloads mais importantes. Por exemplo, você pode adicionar capacidade para controlar o número de consultas que poderão ser executadas simultaneamente, escolher quais workloads poderão usar a capacidade e compartilhar a capacidade entre as workloads. A capacidade é sem servidor e totalmente gerenciada pelo Athena, sendo mantida para você pelo tempo que for necessário. A configuração é fácil, e não é necessário alterar suas consultas SQL.
Para obter capacidade de processamento para suas consultas, crie uma reserva de capacidade, especifique o número de unidades de processamento de dados (DPUs) necessárias e atribua um ou mais grupos de trabalho à reserva.
Os grupos de trabalho têm um papel importante no uso das reservas de capacidade. Os grupos de trabalho permitem organizar consultas em agrupamentos lógicos ou usar casos. Com as reservas de capacidade, atribua seletivamente a capacidade aos grupos de trabalho para controlar como as consultas de cada grupo de trabalho se comportam e como são faturadas. Para obter mais informações sobre grupos de trabalho, consulte [Usar grupos de trabalho para controlar o acesso a consultas e os custos](workgroups-manage-queries-control-costs.md).
A atribuição de grupos de trabalho às reservas de capacidade permite que você dê prioridade a essas consultas porque elas são executadas em sua capacidade reservada e não contam para sua cota de consultas DDL e DML. Por exemplo, você pode alocar capacidade para um grupo de trabalho usado para consultas urgentes de relatórios financeiros para isolá-las de consultas menos essenciais em outro grupo de trabalho. Isso proporciona uma execução de consultas previsível para workloads essenciais, permitindo que outras workloads sejam executadas de forma independente.
Você pode usar reservas de capacidade e grupos de trabalho juntos para cumprir diferentes requisitos. Estes são alguns dos cenários de exemplo:
+ **Isolar consultas importantes**: para garantir que uma workload importante tenha a capacidade necessária quando você precisar, crie uma reserva de capacidade e atribua seu grupo de trabalho à reserva. Somente as consultas do grupo de trabalho designado usam a capacidade de processamento da sua reserva. Por exemplo, para garantir a execução confiável de consultas que oferecem suporte a uma aplicação de produção, atribua o grupo de trabalho de produção dessas consultas a uma reserva de capacidade. Ao desenvolver consultas, use um grupo de trabalho separado que não esteja associado a uma reserva e mova as consultas para o grupo de produção quando estiverem prontas.
+ **Compartilhar capacidade entre workloads semelhantes**: diversas workloads podem compartilhar a capacidade de uma reserva. Isso permite que você obtenha um custo previsível para essas workloads e controle sua simultaneidade. Por exemplo, se você tiver workloads agendadas que tolerem atrasos no início da execução das consultas, é possível atribuir seus grupos de trabalho a uma única reserva. Isso libera sua cota de consultas DDL e DML para consultas interativas executadas na mesma conta, garantindo que essas consultas comecem com o mínimo de atraso.
## Noções básicas de DPUs
A capacidade é medida em unidades de processamento de dados (DPUs). As DPUs representam os recursos sem servidor de computação e memória usados pelo Athena para acessar e processar dados para você. Uma DPU normalmente fornece 4 vCPUs e 16 GB de memória. O número de DPUs que você mantém influencia o número de consultas que você pode executar simultaneamente. Por exemplo, uma reserva com 256 DPUs permite aproximadamente duas vezes mais consultas simultâneas do que uma reserva com 128 DPUs.
Para obter informações sobre como fazer a estimativa de seus requisitos de capacidade, consulte [Determinar requisitos de capacidade](capacity-management-requirements.md). Para obter informações de preço, consulte [Preços do Amazon Athena](https://aws.amazon.com/athena/pricing/).
## Considerações e limitações
+ Você pode usar reservas de capacidade e faturamento por consulta, com base nos dados verificados, ao mesmo tempo na mesma conta.
+ As consultas executadas em reservas de capacidade não contam para sua cota de consultas DDL e DML.
+ Se sua capacidade estiver ocupada atendendo outras consultas, as consultas recém-enviadas serão enfileiradas até que a capacidade esteja disponível. O tempo máximo permitido na fila é de dez horas.
+ Um grupo de trabalho pode ser atribuído a apenas uma reserva de capacidade por vez. Você pode atribuir um total de 20 grupos de trabalho a uma única reserva. Quando você atribui vários grupos de trabalho a uma reserva, a capacidade é compartilhada entre os grupos de trabalho e alocada às consultas com base na ordem de envio. Pode haver variação na ordem de execução devido à forma como o Athena aloca dinamicamente a capacidade às consultas.
+ O Athena aloca automaticamente entre 4 e 124 DPUs para consultas DML com base em sua complexidade. Cada consulta DDL consome 4 DPUs. Para obter mais informações, consulte os seguintes tópicos:
+ [Determinar requisitos de capacidade](capacity-management-requirements.md)
+ [Controlar o uso da capacidade](capacity-management-control-capacity-usage.md)
+ O número mínimo de DPUs necessário com cada reserva de capacidade é 4. Para obter informações de preço, consulte [Preços do Amazon Athena](https://aws.amazon.com/athena/pricing/).
+ É possível criar até 100 reservas de capacidade com até mil DPUs por conta e por região. Caso precise de mais de mil DPUs para seu caso de uso, entre em contato com [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com?subject=Athena Provisioned Capacity DPU Limit Request).
+ As solicitações de capacidade não são garantidas e podem levar até 30 minutos para serem concluídas. A capacidade não é transferível para outra reserva de capacidade, Conta da AWS ou Região da AWS.
+ A métrica do `DPUConsumed` CloudWatch é por grupo de trabalho, não por reserva. Assim, se você mover um grupo de trabalho de uma reserva para outra, a métrica `DPUConsumed` incluirá dados de quando o grupo de trabalho pertencia à primeira reserva. Para obter mais informações sobre o uso de métricas do CloudWatch no Athena, consulte [Monitorar métricas de consultas do Athena com o CloudWatch](query-metrics-viewing.md).
+ Para excluir um grupo de trabalho que tenha sido atribuído a uma reserva, remova antes o grupo de trabalho da reserva.
+ Grupos de trabalho configurados para usar o Apache Spark não são compatíveis.
+ As reservas de capacidade não estão disponíveis nas seguintes Regiões da AWS comerciais:
+ Israel (Tel Aviv)
+ Oriente Médio (Emirados Árabes Unidos)
+ Oriente Médio (Bahrein)
+ Ásia-Pacífico (Nova Zelândia)
**Topics**
+ [
## Noções básicas de DPUs
](#capacity-management-understanding-dpus)
+ [
## Considerações e limitações
](#capacity-management-considerations-limitations)
+ [
# Determinar requisitos de capacidade
](capacity-management-requirements.md)
+ [
# Criar reservas de capacidade
](capacity-management-creating-capacity-reservations.md)
+ [
# Controlar o uso da capacidade
](capacity-management-control-capacity-usage.md)
+ [
# Ajustar a capacidade reservada
](capacity-management-automatically-adjust-capacity.md)
+ [
# Gerenciar reservas
](capacity-management-managing-reservations.md)
+ [
# Políticas do IAM para reservas de capacidade
](capacity-reservations-iam-policy.md)
+ [
# APIs de reserva de capacidade do Athena
](capacity-management-api-list.md)
# Determinar requisitos de capacidade
Antes de criar uma reserva de capacidade, é possível fazer uma estimativa da capacidade necessária para atribuir a ela o número correto de DPUs. E depois que a reserva estiver em uso, convém verificar se a reserva tem capacidade insuficiente ou excessiva. Este tópico descreve as técnicas que você pode usar para fazer essas estimativas e também descreve algumas ferramentas da AWS para avaliar o uso e o custo.
**Topics**
+ [
## Estimar a capacidade necessária
](#capacity-management-requirements-estimating)
+ [
## Sinais da necessidade de mais capacidade
](#capacity-management-requirements-insufficient-capacity)
+ [
## Verificar a capacidade ociosa
](#capacity-management-requirements-idle-capacity)
+ [
## Monitoramento do consumo de DPUs
](#capacity-management-requirements-monitoring-dpu-consumption)
## Estimar a capacidade necessária
Ao estimar os requisitos de capacidade, é útil considerar duas perspectivas: a quantidade de capacidade que uma consulta específica pode exigir e a quantidade de capacidade que você pode precisar em geral.
### Estimar os requisitos de capacidade por consulta
Para determinar o número de DPUs que uma consulta pode exigir, é possível usar as seguintes diretrizes:
+ As consultas DDL consomem 4 DPUs.
+ As consultas DML normalmente consomem entre 4 e 124 DPUs.
O Athena determina o número de DPUs necessárias para uma consulta DML quando a consulta é enviada. O número varia conforme o tamanho dos dados, o formato de armazenamento, a estrutura da consulta e outros fatores. Geralmente, o Athena tenta selecionar o número de DPUs mais baixo e mais eficiente. Se o Athena determinar que é necessário obter mais capacidade computacional para que a consulta seja concluída com êxito, ele aumentará o número de DPUs atribuídas à consulta.
### Estimar os requisitos de capacidade específicos da workload
Para determinar a quantidade de capacidade necessária para executar várias consultas ao mesmo tempo, considere as diretrizes gerais na tabela a seguir:
****
| Consultas simultâneas | DPUs necessárias |
| --- | --- |
| 10 | 40 ou mais |
| 20 | 96 ou mais |
| 30 ou mais | 240 ou mais |
O número real de DPUs necessárias depende de suas metas e padrões de análise. Por exemplo, se você quiser que as consultas comecem imediatamente sem filas, determine o pico de demanda simultânea de consultas e provisione o número de DPUs de acordo.
Você pode provisionar menos DPUs do que sua demanda de pico, mas o enfileiramento poderá ocorrer quando ocorrer o pico de demanda. Quando ocorre o enfileiramento, o Athena mantém as consultas em uma fila e as executa quando a capacidade torna-se disponível.
Se sua meta for executar consultas dentro de um orçamento fixo, você poderá usar a [Calculadora de preços da AWS](https://calculator.aws/#/addService/Athena) para determinar o número de DPUs que cabem em seu orçamento.
Por fim, lembre-se de que o tamanho dos dados, o formato de armazenamento e a forma como uma consulta é escrita influenciam as DPUs necessárias para uma consulta. Para aumentar a performance da consulta, é possível compactar ou particionar os dados ou convertê-los para formatos em colunas. Para obter mais informações, consulte [Otimizar a performance do Athena](performance-tuning.md).
## Sinais da necessidade de mais capacidade
Mensagens de erro de capacidade insuficiente e enfileiramento de consultas são duas indicações de que a capacidade atribuída é inadequada.
Se as consultas falharem com uma mensagem de erro de capacidade insuficiente, o número de DPUs da reserva de capacidade provavelmente será muito baixo para a consulta. Por exemplo, se você tiver uma reserva com 24 DPUs e executar uma consulta que exija mais de 24 DPUs, a consulta falhará. Para monitorar esse erro de consulta, use os [eventos do EventBridge](athena-events.md) do Athena. Tente adicionar mais DPUs e executar a consulta novamente.
Se muitas consultas estiverem em fila, significa que a capacidade foi totalmente utilizada por outras consultas. Para reduzir o enfileiramento, realize uma destas ações:
+ Adicione DPUs à reserva para aumentar a simultaneidade de consultas.
+ Remova grupos de trabalho da reserva para liberar capacidade para outras consultas.
Para verificar se há excesso de filas de consultas, use a [métrica do CloudWatch](query-metrics-viewing.md) de tempo de fila de consultas do Athena para os grupos de trabalho na sua reserva de capacidade. Se o valor estiver acima de seu limite preferencial, você poderá adicionar DPUs à reserva de capacidade.
## Verificar a capacidade ociosa
Para verificar a capacidade ociosa, você pode diminuir o número de DPUs na reserva ou aumentar a workload e observar os resultados.
**Para verificar a capacidade ociosa**
1. Execute um destes procedimentos:
+ Reduza o número de DPUs da reserva (reduza os recursos disponíveis)
+ Adicione grupos de trabalho à reserva (aumente a workload)
1. Use o [CloudWatch](query-metrics-viewing.md) para medir o tempo da fila de consultas.
1. Se o tempo de espera ultrapassar um nível desejável, realize uma destas ações:
+ Remova grupos de trabalho
+ Adicione DPUs à reserva de capacidade
1. Após cada alteração, verifique a performance e o tempo da fila de consultas.
1. Continue ajustando a workload ou a contagem de DPUs para atingir o equilíbrio desejado.
Caso não queira manter a capacidade fora de um período de tempo preferencial, você pode [cancelar](capacity-management-cancelling-a-capacity-reservation.md) a reserva e criar outra reserva posteriormente. Porém, mesmo que você tenha cancelado recentemente a capacidade de outra reserva, as solicitações de nova capacidade não são garantidas e as novas reservas demoram para serem criadas.
## Monitoramento do consumo de DPUs
Depois que suas consultas forem executadas, você poderá visualizar as DPUs consumidas por suas consultas para ajudar a refinar suas estimativas de capacidade. O Athena fornece métricas de consumo de DPU por meio do console, de operações de API e do CloudWatch. Essas informações ajudam a identificar consultas que consomem mais ou menos recursos do que o esperado e a otimizar sua alocação de capacidade com base em dados reais. Para obter informações detalhadas sobre como visualizar e monitorar o consumo de DPUs, consulte [Monitorar o uso de DPU](capacity-management-control-capacity-usage.md#capacity-management-monitor-dpu-usage).
## Ferramentas para avaliar requisitos de capacidade e custo
Você pode usar os serviços e recursos da AWS a seguir para medir o uso e os custos do Athena.
### métricas do CloudWatch
É possível configurar o Athena para publicar métricas relacionadas a consultas no Amazon CloudWatch no nível do grupo de trabalho. Depois que você habilitar as métricas para o grupo de trabalho, as métricas das consultas do grupo de trabalho serão exibidas no console do Athena na página de detalhes do grupo de trabalho.
Para obter informações sobre as métricas do Athena publicadas no CloudWatch e suas dimensões, consulte [Monitorar métricas de consultas do Athena com o CloudWatch](query-metrics-viewing.md).
### Métricas de uso do CloudWatch
Você pode usar as métricas de uso do CloudWatch para fornecer visibilidade de como a conta usa os recursos, exibindo o uso do serviço atual nos gráficos e painéis do CloudWatch. Para o Athena, as métricas de disponibilidade para uso correspondem às [cotas de serviço](service-limits.md) da AWS para o Athena. Também é possível configurar alarmes que alertem você quando o uso se aproximar de uma cota de serviço.
Para obter mais informações, consulte [Monitorar métricas de uso do Athena com o CloudWatch](monitoring-athena-usage-metrics.md).
### Eventos do Amazon EventBridge
Você pode usar o Amazon Athena com o Amazon EventBridge para receber notificações em tempo real sobre o estado das consultas. Quando o estado de uma consulta enviada é alterado, o Athena publica um evento no EventBridge que contém informações sobre a transição de estado da consulta. É possível gravar regras simples para eventos do seu interesse e realizar ações automatizadas quando um evento corresponder a uma regra.
Para obter mais informações, consulte os recursos a seguir.
+ [Monitorar eventos de consulta do Athena com o EventBridge](athena-events.md)
+ [O que é o Amazon EventBridge?](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html)
+ [Eventos do Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html)
### Tags
No Athena, as reservas de capacidade são compatíveis com etiquetas. Uma etiqueta consiste em uma chave e um valor. Para rastrear seus custos no Athena, você pode usar etiquetas de alocação de custos geradas pela AWS. A AWS utiliza as etiquetas de alocação de custos para organizar os custos de recursos em seu [Relatório de Custos e Uso](https://docs.aws.amazon.com/cur/latest/userguide/what-is-cur.html). Isso facilita a categorização e o controle de seus custos na AWS. Para ativar as etiquetas de alocação de custos para o Athena, use o [console do Gerenciamento de Faturamento e Custos da AWS](https://console.aws.amazon.com/billing/).
Para obter mais informações, consulte os recursos a seguir.
+ [Marcar recursos do Athena com tags](tags.md)
+ [Como ativar as etiquetas de alocação de custos geradas pela AWS](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activate-built-in-tags.html)
+ [Usar etiquetas de alocação de custos da AWS](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)
# Criar reservas de capacidade
Para começar, crie uma reserva de capacidade com o número de DPUs necessárias e atribua um ou mais grupos de trabalho que usarão essa capacidade nas consultas. É possível ajustar sua capacidade posteriormente, conforme necessário, para fornecer uma performance mais consistente ou gerenciar melhor os custos. Para obter informações sobre como fazer a estimativa de seus requisitos de capacidade, consulte [Determinar requisitos de capacidade](capacity-management-requirements.md).
**Importante**
As solicitações de capacidade não são garantidas e podem levar até 30 minutos para serem concluídas.
**Para criar uma reserva de capacidade**
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.
1. Escolha **Administração**, **Reservas de capacidade**.
1. Escolha **Criar reserva de capacidade**.
1. Na página **Criar reserva de capacidade**, em **Nome da reserva de capacidade**, insira o nome. O nome deve ser exclusivo, conter de 1 a 128 caracteres e usar apenas os seguintes caracteres: A-Z, 0-9, \$1 (sublinhado), . (ponto) e - (hífen). Não é possível alterar o nome depois de criar a reserva.
1. Em **DPU**, escolha ou insira o número de unidades de processamento de dados (DPUs) que deseja em incrementos de 4. Para obter mais informações, consulte [Noções básicas de DPUs](capacity-management.md#capacity-management-understanding-dpus).
1. (Opcional) Expanda a opção **Etiquetas** e escolha **Adicionar nova etiqueta** para adicionar um ou mais pares de chave/valor personalizados para associar ao recurso de reserva de capacidade. Para obter mais informações, consulte [Marcar recursos do Athena com tags](tags.md).
1. Escolha **Revisar**.
1. No prompt **Confirmar criação de reserva de capacidade**, confirme o número de DPUs, a Região da AWS e outras informações. Se você aceitar, escolha **Enviar**.
Na página de detalhes, o **Status** da reserva de capacidade é exibido como **Pendente**. Quando sua capacidade de reserva estiver disponível para executar consultas, o status será exibido como **Ativa**.
Neste ponto, você está pronto para adicionar um ou mais grupos de trabalho à reserva. Para obter as etapas, consulte [Adicionar grupos de trabalho a uma reserva](capacity-management-adding-workgroups-to-a-reservation.md).
# Controlar o uso da capacidade
Você pode controlar o número de DPUs que o Athena aloca para suas consultas definindo controles de DPU máximo ou mínimo. Você pode configurá-los no nível do grupo de trabalho para estabelecer controles de linha de base para todas as consultas, ou no nível de consulta individual para um controle refinado. Isso lhe dá controle direto sobre a performance da consulta, a simultaneidade das workloads e os custos.
+ Quando você define um número máximo de DPUs, as consultas são impedidas de consumir mais capacidade do que você especifica. Isso simplifica o controle de custos e a simultaneidade das workloads. Por exemplo, se sua reserva de capacidade tiver 200 DPU, definir a DPU máxima por consulta como 8 permitirá que você execute 25 consultas simultaneamente. Se você aumentar sua reserva para 400 DPUs, poderá executar 50 consultas simultaneamente.
+ Ao definir um número mínimo de DPU, você garante que as consultas sejam executadas com o número mínimo desejado de DPUs. Isso é útil quando você sabe com antecedência o perfil típico de uso da capacidade das suas consultas.
**nota**
Os controles de uso de DPUs se aplicam somente às consultas executadas com reservas de capacidade.
**nota**
Para usar o mesmo número de DPUs para todas as consultas, use o mesmo valor para a DPU mínima e máxima.
## Definir controles de DPU no nível do grupo de trabalho
Defina controles de DPU no nível do grupo de trabalho para gerenciar os custos e controlar a performance das workloads para o grupo de trabalho que você escolher. Os controles de DPU definidos no nível do grupo de trabalho se aplicam a todas as consultas quando a opção **Substituir as configurações do lado do cliente** está habilitada.
**Para definir os controles de DPU usando o console**
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 **Global networks** (Redes globais).
1. Selecione um grupo de trabalho que use uma reserva de capacidade.
1. Na guia **Controles de execução**, escolha **Editar controles**.
1. Configure o seguinte:
+ Em **DPU mínimo por consulta**, insira um valor entre 4 e 124 em incrementos de 4.
+ Em **DPU máximo por consulta**, insira um valor entre 4 e 124 em incrementos de 4.
1. Escolha **Salvar**.
1. (Opcional) Selecione **Substituir as configurações do lado do cliente** para aplicar essas configurações e ignorar as configurações de DPU no nível de consulta.
**Para definir controles de DPU usando a AWS CLI**
+ Use o comando `update-work-group` para definir controles de DPU para um grupo de trabalho:
```
aws athena update-work-group \
--work-group my_workgroup \
--configuration-updates '{
"EngineConfiguration": {
"Classifications": [
{
"Name": "athena-query-engine-properties",
"Properties": {
"max-dpu-count" : "24",
"min-dpu-count" : "12"
}
}
]
}}'
```
Se você definir `EnforceWorkGroupConfiguration` como `true`, as configurações do grupo de trabalho substituirão quaisquer controles de DPU especificados no nível da consulta quando enviados via [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html). Isso garante uma alocação consistente de recursos em todas as consultas no grupo de trabalho.
## Definir controles de DPU com consultas individuais
Defina controles de DPU no nível de consulta quando precisar de um controle refinado com consultas que tenham requisitos de recursos diferentes. Os controles de DPU no nível da consulta têm precedência sobre as configurações no nível do grupo de trabalho, a menos que o grupo de trabalho tenha a opção **Substituir as configurações do lado do cliente** habilitada.
**Para definir controles de DPU para uma consulta usando o console**
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, selecione **Query editor (Editor de consultas)**.
1. Selecione um grupo de trabalho que use uma reserva de capacidade.
1. Escolha a guia **Configurações da consulta**.
1. Na seção **Controles de execução**, escolha **Editar controles**.
1. Configure o seguinte:
+ Em **DPU mínimo por consulta**, insira um valor entre 4 e 124 em incrementos de 4.
+ Em **DPU máximo por consulta**, insira um valor entre 4 e 124 em incrementos de 4.
1. Escolha **Salvar**.
**Para definir controles de DPU para uma consulta usando a AWS CLI**
+ Use o comando `start-query-execution` com o parâmetro `engine-configuration`:
```
aws athena start-query-execution \
--query-string "SELECT * FROM my_table LIMIT 10" \
--work-group "my_workgroup" \
--engine-configuration '{
"Classifications": [ {
"Name": "athena-query-engine-properties",
"Properties": {
"max-dpu-count" : "32",
"min-dpu-count" : "8"
}
}
]}'
```
A relação entre as configurações de DPU no nível da consulta e no nível do grupo de trabalho depende da configuração do seu grupo de trabalho:
+ Quando a opção **Substituir as configurações do lado do cliente** está habilitada, os controles de DPU no nível do grupo de trabalho têm precedência sobre qualquer configuração no nível da consulta. Isso garante o uso consistente dos recursos para todas as consultas no grupo de trabalho especificado.
+ Quando a opção **Substituir as configurações do lado do cliente** não está habilitada, os controles de DPU no nível da consulta têm precedência sobre as configurações no nível do grupo de trabalho. Isso oferece flexibilidade para otimizar as consultas individuais.
Se você não especificar controles de DPU em nenhum dos níveis, o Athena alocará automaticamente a capacidade com base na complexidade da consulta.
**nota**
Para consultas DDL, o valor máximo para o mínimo de DPU é 4. Definir um mínimo mais alto para consultas DDL resulta em erro.
## Monitorar o uso de DPU
Após as consultas serem concluídas, você pode visualizar seu uso de DPUs. O Athena fornece métricas de uso de DPU por meio do console, de operações de API e do CloudWatch.
**Para ver o consumo de DPUs no console**
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, selecione **Query editor (Editor de consultas)**.
1. Depois que uma consulta for concluída, visualize seu valor de **DPU consumido** no contêiner de resultados da consulta.
1. Para ver o consumo de DPU de consultas anteriores:
1. No painel de navegação, escolha **Consultas recentes**.
1. Selecione o ícone de configurações para adicionar a coluna **DPUs consumidas** à tabela, caso ainda não esteja exibida.
1. Analise o consumo de DPUs para cada consulta concluída.
1. Opcionalmente, no **Editor de consultas**, escolha a guia **Estatísticas da consulta** e revise as **DPUs consumidas**.
**Para recuperar o consumo de DPU usando a API**
1. Use as seguintes operações de API para recuperar o consumo de DPU de forma programática:
+ `GetQueryExecution`: retorna detalhes da execução de uma consulta específica
+ `BatchGetQueryExecution`: retorna detalhes da execução de várias consultas
1. Exemplo: usando a AWS CLI:
```
aws athena get-query-execution \
--query-execution-id "123e4567-e89b-12d3-a456-426614174000"
```
A resposta inclui o campo `DpuCount` no objeto `Statistics`:
```
{
"QueryExecution": {
"Statistics": {
"DpuCount": 8
}
}
}
```
**Para monitorar o uso de DPU com o CloudWatch**
+ O Athena publica métricas relacionadas a consultas no CloudWatch que ajudam você a monitorar a utilização da capacidade e outros dados de performance. Para saber mais, consulte [Monitorar métricas de consultas do Athena com o CloudWatch](query-metrics-viewing.md).
# Ajustar a capacidade reservada
Você pode ajustar automaticamente a capacidade da sua reserva em resposta à utilização das workloads usando a solução de ajuste de escala automático do Athena. Ele adiciona capacidade automaticamente quando a utilização excede o limite configurado e remove a capacidade durante períodos de baixa utilização para reduzir custos. Você pode personalizar seu comportamento definindo diferentes limites de utilização, quantidades mínimas e máximas de DPU, incrementos de escalabilidade e frequência de avaliação de utilização. Isso elimina os ajustes manuais de capacidade e ajuda você a equilibrar os requisitos de performance com a otimização de custos.
Você implanta essa solução sem servidor usando um modelo do CloudFormation. Ele cria uma máquina de estado do Step Functions que monitora as métricas de utilização e toma decisões de escalabilidade. Você pode personalizar ainda mais o modelo ou a máquina de estado para atender às suas necessidades específicas.
Para começar, use o console do Athena e escolha **Configurar o ajuste de escala automático** na página de detalhes da reserva de capacidade, que redireciona você para o CloudFormation com o modelo pré-carregado. Como alternativa, siga o procedimento abaixo.
## Pré-requisitos
+ É necessária uma reserva de capacidade ativa
+ Permissões do IAM necessárias para implantar pilhas do CloudFormation e criar recursos do Step Functions
## Iniciar a pilha do CloudFormation
Esse modelo automatizado do CloudFormation implanta a solução de ajuste de escala automático da reserva de capacidade do Athena. Você deve concluir as etapas aplicáveis em [Pré-requisitos](#capacity-management-auto-scaling-prerequisites) antes de iniciar a pilha.
[https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?&templateURL=https:%2F%2Fathena-downloads.s3.us-east-1.amazonaws.com%2F%2Ftemplates%2F%2Fcapacity-reservation-scaling%2F%2Fstate-machine%2F%2Fathena-capacity-reservation-scaling-template-v1.1.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?&templateURL=https:%2F%2Fathena-downloads.s3.us-east-1.amazonaws.com%2F%2Ftemplates%2F%2Fcapacity-reservation-scaling%2F%2Fstate-machine%2F%2Fathena-capacity-reservation-scaling-template-v1.1.yaml)
**Para iniciar a solução de ajuste de escala automático**
1. Faça login no [Console de Gerenciamento da AWS](https://console.aws.amazon.com/) e selecione o botão para iniciar o modelo `AWSAccelerator-InstallerStack` do CloudFormation.
1. O modelo é iniciado na região Leste dos EUA (Norte da Virgínia) por padrão. Para iniciar a solução em outra Região da AWS, use o seletor de região na barra de navegação do console.
1. Na página **Criar pilha**, verifique se o URL do modelo está na caixa de texto **URL do Amazon S3** e escolha **Avançar**.
1. Na página **Especificar detalhes da pilha**, atribua um nome para a sua pilha de soluções.
1. Em **Parâmetros**, revise os parâmetros do modelo dessa solução e modifique-os conforme requerido. Esta solução usa os seguintes valores padrão.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/capacity-management-automatically-adjust-capacity.html)
**nota**
Todos os valores de DPU devem ser múltiplos de 4 para atender aos requisitos de reserva de capacidade do Athena.
1. Escolha **Avançar**.
1. Na página **Configurar opções de pilha**, selecione **Avançar**.
1. Na página **Revisar e criar**, revise e confirme as configurações. Marque a caixa de seleção confirmando que o modelo poderá criar recursos do IAM.
1. Escolha **Enviar** para implantar a pilha.
Você pode visualizar o status da pilha no console do CloudFormation, na coluna **Status**. Você receberá o status `CREATE_COMPLETE` em poucos minutos.
# Gerenciar reservas
Visualize e gerencie suas reservas de capacidade na página **Reservas de capacidade**. Você pode realizar tarefas de gerenciamento, como adicionar ou reduzir DPUs, modificar atribuições de grupos de trabalho e etiquetar ou cancelar reservas.
**Para visualizar e gerenciar reservas de capacidade**
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.
1. Escolha **Administração**, **Reservas de capacidade**.
1. Na página de reserva de capacidade, é possível realizar estas tarefas:
+ Para criar uma reserva de capacidade, escolha **Criar reserva de capacidade**.
+ Use a caixa de pesquisa para filtrar reservas por nome ou número de DPUs.
+ Escolha o menu suspenso de status para filtrar por status de reserva de capacidade (por exemplo, **Ativa** ou **Cancelada**). Para obter informações sobre status de reservas, consulte [Noções básicas de status de reserva](#capacity-management-understanding-reservation-status).
+ Para visualizar os detalhes de uma reserva de capacidade, escolha o link da reserva. A página de detalhes da reserva contém opções para [editar a capacidade](capacity-management-editing-capacity-reservations.md), [adicionar grupos de trabalho](capacity-management-adding-workgroups-to-a-reservation.md), [remover grupos de trabalho](capacity-management-removing-a-workgroup-from-a-reservation.md) e [cancelar](capacity-management-cancelling-a-capacity-reservation.md) a reserva.
+ Para editar uma reserva (por exemplo, adicionar ou remover DPUs), selecione o botão da reserva e escolha **Editar**.
+ Para cancelar uma reserva, selecione o botão da reserva e escolha **Cancelar**.
## Noções básicas de status de reserva
A tabela a seguir descreve os possíveis valores de status de uma reserva de capacidade.
****
| Status | Descrição |
| --- | --- |
| Pendente | O Athena está processando sua solicitação de capacidade. A capacidade não está pronta para executar consultas. |
| Ativo | A capacidade está disponível para executar consultas. |
| Failed | A solicitação de capacidade não foi concluída com êxito. O cumprimento das solicitações de capacidade não é garantido. As reservas com falha contam para os limites de DPU da conta. Para liberar o uso, é necessário cancelar a reserva. |
| Atualização pendente | O Athena está processando uma alteração na reserva. Por exemplo, esse status ocorre depois que você edita a reserva para adicionar ou remover DPUs. |
| Cancelando | O Athena está processando uma solicitação para cancelar a reserva. As consultas que ainda estiverem em execução nos grupos de trabalho que estavam usando a reserva poderão ser concluídas, mas outras consultas do grupo de trabalho usarão capacidade sob demanda (não provisionada). |
| Cancelado | O cancelamento da reserva de capacidade foi concluído. As reservas canceladas permanecerão no console por 45 dias. Após 45 dias, o Athena excluirá a reserva. Durante os 45 dias, não será possível reaproveitar ou reutilizar a reserva, mas você poderá consultar as etiquetas e visualizar os detalhes para referência histórica. Não é garantido que a capacidade cancelada será reservada novamente em uma data futura. A capacidade não pode ser transferida para outra reserva, Conta da AWS ou Região da AWS. |
## Noções básicas de DPUs ativas e DPUs de destino
Na lista de reservas de capacidade no console Athena, a reserva exibe dois valores de DPU: **DPU ativa** e **DPU de destino**.
+ **DPU ativa**: o número de DPUs que estão disponíveis na reserva para executar consultas. Por exemplo, se você solicitar 100 DPUs e a solicitação for atendida, a **DPU ativa** exibirá **100**.
+ **DPU de destino**: o número de DPUs para as quais a reserva está sendo transferida. A **DPU de destino** exibe um valor diferente da **DPU ativa** quando uma reserva está sendo criada ou há um aumento ou uma diminuição no número de DPUs pendente.
Por exemplo, depois que você enviar uma solicitação para criar uma reserva com 24 DPUs, o **Status** da reserva será **Pendente**, a **DPU ativa** será **0** e a **DPU de destino** será **24**.
Se você tiver uma reserva com 100 DPUs e editar a reserva para solicitar um aumento de 20 DPUs, o **Status** será **Atualização pendente**, a **DPU ativa** será **100** e a **DPU de destino** será **120**.
Se você tiver uma reserva com 100 DPUs e editar a reserva para solicitar uma redução de 20 DPUs, o **Status** será **Atualização pendente**, a **DPU ativa** será **100** e a **DPU de destino** será **80**.
Durante essas transições, o Athena trabalha ativamente para adquirir ou reduzir o número de DPUs com base na solicitação. Quando a **DPU ativa** torna-se igual à **DPU de destino**, o número de destino foi atingido e não há alterações pendentes.
Para recuperar esses valores de forma programática, você pode chamar a ação da API [GetCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCapacityReservation.html). A API refere-se à **DPU ativa** e à **DPU de destino** como `AllocatedDpus` e `TargetDpus`.
**Topics**
+ [
## Noções básicas de status de reserva
](#capacity-management-understanding-reservation-status)
+ [
## Noções básicas de DPUs ativas e DPUs de destino
](#capacity-management-understanding-dpu-status)
+ [
# Editar reservas de capacidade
](capacity-management-editing-capacity-reservations.md)
+ [
# Adicionar grupos de trabalho a uma reserva
](capacity-management-adding-workgroups-to-a-reservation.md)
+ [
# Remover um grupo de trabalho de uma reserva
](capacity-management-removing-a-workgroup-from-a-reservation.md)
+ [
# Cancelar uma reserva de capacidade
](capacity-management-cancelling-a-capacity-reservation.md)
+ [
# Excluir uma reserva de capacidade
](capacity-management-deleting-a-capacity-reservation.md)
# Editar reservas de capacidade
Após criar uma reserva de capacidade, você pode ajustar o número de DPUs e adicionar ou remover as etiquetas personalizadas.
**Para editar uma reserva de capacidade**
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.
1. Escolha **Administração**, **Reservas de capacidade**.
1. Na lista de reservas de capacidade, siga um destes procedimentos:
+ Selecione o botão ao lado da reserva e escolha **Editar**.
+ Escolha o link da reserva e depois **Editar**.
1. Em **DPU**, escolha ou insira o número de unidades de processamento de dados desejada. Para obter mais informações, consulte [Noções básicas de DPUs](capacity-management.md#capacity-management-understanding-dpus).
**nota**
Você pode solicitar a adição de DPUs a uma reserva de capacidade ativa a qualquer momento.
Você pode solicitar a redução das DPUs de uma reserva de capacidade ativa quando tiver decorrido 1 minuto desde que a reserva se tornou ativa ou desde que as DPUs foram adicionadas pela última vez.
Quando você solicita a redução de DPUs, o Athena prioriza a remoção de DPUs ociosas em vez de DPUs ativas. Se as consultas estiverem consumindo DPUs marcadas para remoção, o Athena aguarda a conclusão das consultas antes de remover as DPUs.
1. Em **Etiquetas**, selecione **Remover** para remover uma etiqueta ou escolha **Adicionar etiqueta** para adicionar uma nova etiqueta.
1. Selecione **Enviar**. A página de detalhes da reserva mostra a configuração atualizada.
# Adicionar grupos de trabalho a uma reserva
Depois de criar uma reserva de capacidade, é possível adicionar até 20 grupos de trabalho à reserva. Adicionar um grupo de trabalho a uma reserva informa ao Athena quais consultas deverão ser executadas na capacidade reservada. As consultas de grupos de trabalho que não estão associados a uma reserva continuam sendo executadas usando o modelo de preço padrão por terabyte (TB) verificado.
Quando uma reserva tem dois ou mais grupos de trabalho, as consultas desses grupos de trabalho podem usar a capacidade da reserva. É possível adicionar e remover grupos de trabalho a qualquer momento. Quando você adicionar ou remover grupos de trabalho, as consultas em execução não serão interrompidas.
Quando a reserva está pendente, as consultas dos grupos de trabalho que você adicionou continuam sendo executadas usando o modelo de preço padrão por terabyte (TB) verificado até que a reserva torne-se ativa.
**Para adicionar um ou mais grupos de trabalho à reserva de capacidade**
1. Na página de detalhes da reserva de capacidade, escolha **Adicionar grupos de trabalho**.
1. Na página **Adicionar grupos de trabalho**, selecione os grupos de trabalho que deseja adicionar e escolha **Adicionar grupos de trabalho**. Não é possível atribuir um grupo de trabalho a mais de uma reserva.
A página de detalhes da reserva de capacidade lista os grupos de trabalho que você adicionou. As consultas executadas nesses grupos de trabalho usarão a capacidade que você reservou quando a reserva estiver ativa.
# Remover um grupo de trabalho de uma reserva
Caso não precise mais de capacidade dedicada para um grupo de trabalho ou se quiser mover um grupo de trabalho para sua própria reserva, poderá removê-lo a qualquer momento. A remoção de um grupo de trabalho de uma reserva é um processo simples. Depois de remover um grupo de trabalho de uma reserva, as consultas do grupo de trabalho removido usam como padrão a capacidade sob demanda e são faturadas com base nos terabytes (TB) verificados.
**Para remover um ou mais grupos de trabalho de uma reserva**
1. Na página de detalhes da reserva de capacidade, selecione os grupos de trabalho que deseja remover.
1. Escolha **Remover grupos de trabalho**. O prompt **Remover grupos de trabalho?** informa que todas as consultas ativas no momento serão concluídas antes que o grupo de trabalho seja removido da reserva.
1. Escolha **Remover**. A página de detalhes da reserva de capacidade mostra que os grupos de trabalho removidos não estão mais presentes.
# Cancelar uma reserva de capacidade
Caso não queira mais usar uma reserva de capacidade, você pode cancelá-la. As consultas que ainda estiverem em execução nos grupos de trabalho que estavam usando a reserva poderão ser concluídas, mas outras consultas do grupo de trabalho não usarão mais a reserva.
**nota**
Não é garantido que a capacidade cancelada será reservada novamente em uma data futura. A capacidade não pode ser transferida para outra reserva, Conta da AWS ou Região da AWS.
**Para cancelar uma reserva de capacidade**
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.
1. Escolha **Administração**, **Reservas de capacidade**.
1. Na lista de reservas de capacidade, siga um destes procedimentos:
+ Selecione o botão ao lado da reserva e escolha **Cancelar**.
+ Escolha o link da reserva e escolha **Cancelar reserva de capacidade**.
1. No prompt **Cancelar reserva de capacidade?**, insira **cancel** e escolha **Cancelar reserva de capacidade**.
O status da reserva é alterado para **Cancelando** e um banner de progresso informa que o cancelamento está em andamento.
Quando o cancelamento for concluído, a reserva de capacidade permanecerá, mas o status será exibido como **Cancelada**. A reserva será excluída 45 dias após o cancelamento. Durante os 45 dias, não será possível reaproveitar ou reutilizar a reserva que foi cancelada, mas você poderá consultar as etiquetas e visualizá-la para referência histórica.
# Excluir uma reserva de capacidade
Se você quiser remover todas as referências a uma reserva de capacidade cancelada, poderá excluir a reserva. Uma reserva deve ser cancelada para poder ser excluída. Uma reserva excluída é imediatamente removida da conta e não pode mais ser referenciada, nem por seu ARN.
**Para excluir uma reserva de capacidade**
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.
1. Escolha **Administração**, **Reservas de capacidade**.
1. Na lista de reservas de capacidade, siga um destes procedimentos:
+ Selecione o botão ao lado da reserva e escolha **Ações**, **Excluir**.
+ Escolha o link da reserva e depois **Excluir**.
1. No prompt **Excluir reserva de capacidade?**, escolha **Excluir**.
Um banner informa que a reserva de capacidade foi excluída com sucesso. A reserva excluída não aparece mais na lista de reservas de capacidade.
# Políticas do IAM para reservas de capacidade
Para controlar o acesso a reservas de capacidade, use permissões do IAM no nível do recurso ou políticas do IAM baseadas em identidade. Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
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 exemplos de políticas de reservas de capacidade do JSON, consulte [Exemplo de políticas de reserva de capacidade](example-policies-capacity-reservations.md).
**Para usar o editor visual no console do IAM para criar uma política de reserva de capacidade**
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 **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 `capacity-reservation` no Athena, o editor listará o recurso `capacity-reservation`.
1. Escolha **Recursos** para especificar as reservas de capacidade específicas de sua política. Para obter exemplos de políticas de reserva de capacidade do JSON, consulte [Exemplo de políticas de reserva de capacidade](example-policies-capacity-reservations.md).
1. Especifique o recurso `capacity-reservation` da seguinte forma:
```
arn:aws:athena:::capacity-reservation/
```
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 política a um usuário, um grupo ou uma função.
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 exemplos de políticas de reserva de capacidade do JSON, consulte [Exemplo de políticas de reserva de capacidade](example-policies-capacity-reservations.md).
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/).
# Exemplo de políticas de reserva de capacidade
Esta seção inclui exemplos de políticas que você pode usar para habilitar várias ações nas reservas de capacidade. Sempre que você usar as políticas do IAM, siga as práticas recomendadas do IAM. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
A reserva de capacidade é um recurso do IAM gerenciado pelo Athena. Portanto, se sua política de reserva de capacidade utiliza ações que usam `capacity-reservation` como entrada, especifique o ARN da reserva de capacidade da seguinte maneira:
```
"Resource": [arn:aws:athena:::capacity-reservation/]
```
Em que `` é o nome da reserva de capacidade. Por exemplo, para uma reserva de capacidade denominada `test_capacity_reservation`, especifique-a como recurso da seguinte forma:
```
"Resource": ["arn:aws:athena:us-east-1:123456789012:capacity-reservation/test_capacity_reservation"]
```
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*.
**Example Exemplo de política para listar reservas de capacidade**
A política a seguir permite que todos os usuários listem todas as reservas de capacidade.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListCapacityReservations"
],
"Resource": "*"
}
]
}
```
**Example Exemplo de política para operações de gerenciamento**
A política a seguir permite que o usuário crie, cancele, obtenha detalhes e atualize a reserva de capacidade `test_capacity_reservation`. A política também permite que o usuário atribua `workgroupA` e `workgroupB` a `test_capacity_reservation`.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"athena:CreateCapacityReservation",
"athena:GetCapacityReservation",
"athena:CancelCapacityReservation",
"athena:UpdateCapacityReservation",
"athena:GetCapacityAssignmentConfiguration",
"athena:PutCapacityAssignmentConfiguration"
],
"Resource": [
"arn:aws:athena:us-east-1:123456789012:capacity-reservation/test_capacity_reservation",
"arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA",
"arn:aws:athena:us-east-1:123456789012:workgroup/workgroupB"
]
}
]
}
```
# APIs de reserva de capacidade do Athena
A lista a seguir contém links de referência para as ações de API de reserva de capacidade do Athena. Para obter estruturas de dados e outras ações de API do Athena, consulte [https://docs.aws.amazon.com/athena/latest/APIReference/](https://docs.aws.amazon.com/athena/latest/APIReference/) (Referência para APIs do Amazon Athena).
+ [CancelCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_CancelCapacityReservation.html)
+ [CreateCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateCapacityReservation.html)
+ [DeleteCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteCapacityReservation.html)
+ [GetCapacityAssignmentConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCapacityAssignmentConfiguration.html)
+ [GetCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCapacityReservation.html)
+ [ListCapacityReservations](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListCapacityReservations.html)
+ [PutCapacityAssignmentConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_PutCapacityAssignmentConfiguration.html)
+ [UpdateCapacityReservation](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateCapacityReservation.html)
# Otimizar a performance do Athena
Este tópico fornece informações gerais e sugestões específicas para melhorar a performance de suas consultas do Athena e como resolver erros relacionados a limites e ao uso de recursos.
Em termos gerais, as otimizações podem ser agrupadas em categorias de serviço, consulta e estrutura de dados. As decisões tomadas no nível do serviço, sobre como você escreve suas consultas e como estrutura seus dados e tabelas, podem influenciar a performance.
**Topics**
+ [
# Otimização do uso do serviço
](performance-tuning-service-level-considerations.md)
+ [
# Otimizar consultas
](performance-tuning-query-optimization-techniques.md)
+ [
# Otimizar dados
](performance-tuning-data-optimization-techniques.md)
+ [
# Usar formatos de armazenamento colunares
](columnar-storage.md)
+ [
# Usar particionamento e bucketing
](ctas-partitioning-and-bucketing.md)
+ [
# Particionar dados
](partitions.md)
+ [
# Usar projeção de partições com o Amazon Athena
](partition-projection.md)
+ [
# Prevenir o controle de utilização do Amazon S3
](performance-tuning-s3-throttling.md)
+ [
# Recursos adicionais
](performance-tuning-additional-resources.md)
# Otimização do uso do serviço
As considerações sobre o nível de serviço incluem o número de workloads que você executa por conta, as Service Quotas não apenas para o Athena, mas para todos os serviços, e o pensamento sobre como reduzir os erros de falta de recursos.
**Topics**
+ [
## Operar várias workloads na mesma conta
](#performance-tuning-service-quotas)
+ [
## Reduzir erros de "falta de recursos"
](#performance-tuning-resource-limits)
## Operar várias workloads na mesma conta
O Athena usa cotas para limitar a simultaneidade de consultas e as taxas de solicitação de API no nível da conta. Exceder essas cotas pode gerar falhas nas consultas durante a execução ou no momento do envio. Para obter mais informações sobre essas cotas, consulte [Service Quotas](service-limits.md).
Se você operar várias workloads na mesma conta da AWS, elas competirão pela mesma cota no nível da conta. Por exemplo, se uma workload sofrer uma explosão inesperada de consultas, outra workload em execução na mesma conta poderá ter um tempo de fila elevado ou, na pior das hipóteses, falhas no envio da consulta devido ao controle de utilização.
Recomendamos que você use o CloudWatch para monitorar a utilização do serviço por meio de gráficos e painéis. É possível também configurar alarmes do CloudWatch que emitam alertas quando a utilização se aproximar da cota de serviço para consultas simultâneas, permitindo que medidas sejam tomadas antes que os limites de cota sejam atingidos. Para obter mais informações, consulte [Monitorar métricas de uso do Athena com o CloudWatch](monitoring-athena-usage-metrics.md).
Para controlar a simultaneidade de consultas e isolar as workloads da sua conta, use reservas de capacidade. As reservas de capacidade fornecem capacidade dedicada de processamento de consultas dentro de uma única conta. A capacidade é medida em unidades de processamento de dados (DPUs) e pode ser adicionada ou removida para aumentar ou diminuir a simultaneidade de consultas, respectivamente. As reservas de capacidade permitem que você isole as workloads umas das outras dentro da conta designando capacidade a um ou mais grupos de trabalho. Para obter mais informações, consulte [Gerenciar a capacidade de processamento de consulta](capacity-management.md).
Embora você deva isolar as workloads não relacionadas em contas diferentes da AWS (como isolar o ambiente de desenvolvimento do ambiente de produção), essa abordagem não oferece uma maneira escalável de aumentar a simultaneidade de consultas. Em vez disso, use reservas de capacidade para gerenciar e escalar as necessidades de processamento de consultas dentro de uma única conta.
### Considerar as cotas em outros serviços
Ao executar uma consulta, o Athena pode chamar outros serviços que impõem cotas. Durante a execução da consulta, o Athena pode fazer chamadas de API para o AWS Glue Data Catalog, o Amazon S3 e outros serviços da AWS, como o IAM e o AWS KMS. Se você usar [consultas federadas](federated-queries.md), o Athena também chamará o AWS Lambda. Todos esses serviços têm seus próprios limites e cotas que podem ser excedidos. Quando a execução de uma consulta encontra erros nesses serviços, ela falha e inclui o erro do serviço de origem. Os erros recuperáveis são repetidos, mas as consultas ainda poderão falhar se o problema não for resolvido a tempo. Leia atentamente as mensagens de erro para determinar se elas vêm do Athena ou de outro serviço. Alguns erros relevantes são abordados nesta seção de ajuste de desempenho.
Para obter mais informações sobre como resolver erros causados por cotas de serviço do Amazon S3, consulte [Evite ter uma quantidade muito grande de arquivos](performance-tuning-data-optimization-techniques.md#performance-tuning-avoid-having-too-many-files) mais adiante neste documento. Para obter mais informações sobre a otimização de performance do Amazon S3, consulte [Padrões de design de práticas recomendadas: otimizar a performance do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) no *Guia do usuário do Amazon S3*.
## Reduzir erros de "falta de recursos"
O Athena executa consultas em um mecanismo de consulta distribuído. Quando você envia uma consulta, o planejador de consultas do mecanismo do Athena estima a capacidade computacional necessária para executar a consulta e prepara devidamente um cluster de nós de computação. Algumas consultas, como consultas DDL, são executadas em apenas um nó. Consultas complexas baseadas em grandes conjuntos de dados são executadas em clusters muito maiores. Os nós são uniformes e têm as mesmas configurações de memória, CPU e disco. O Athena aumenta a escala horizontalmente, não verticalmente, para processar consultas mais exigentes.
Às vezes, as demandas de uma consulta excedem os recursos disponíveis para o cluster que está executando a consulta. Quando isso acontece, a consulta falha com o erro Query exhausted resources at this scale factor.
O recurso que se esgota com mais frequência é a memória, mas em casos raros também pode ser o espaço em disco. Os erros de memória geralmente ocorrem quando o mecanismo executa uma função de junção ou janela, mas também podem ocorrer em contagens e agregações distintas.
Mesmo que a consulta falhe com um erro de “falta de recursos” uma vez, ela pode ter êxito ao ser executada novamente. A execução da consulta não é determinística. Fatores como o tempo necessário para carregar os dados e como os conjuntos de dados intermediários serão distribuídos pelos nós podem resultar em diferentes usos de recursos. Por exemplo, imagine uma consulta que une duas tabelas e tem uma grande distorção na distribuição dos valores da condição de junção. A consulta pode ter êxito na maioria das vezes, mas ocasionalmente falha quando os valores mais comuns acabam sendo processados pelo mesmo nó.
Para evitar que suas consultas excedam os recursos disponíveis, use as dicas de ajuste de performance mencionadas neste documento. Em particular, para obter dicas sobre como otimizar consultas que esgotam os recursos disponíveis, consulte [Otimizar junções](performance-tuning-query-optimization-techniques.md#performance-tuning-optimizing-joins), [Reduzir o escopo das funções da janela ou removê-las](performance-tuning-query-optimization-techniques.md#performance-tuning-optimizing-window-functions) e [Otimizar consultas com o uso de aproximações](performance-tuning-query-optimization-techniques.md#performance-tuning-optimizing-queries-by-using-approximations).
# Otimizar consultas
Use as técnicas de otimização de consulta descritas nesta seção para fazer com que as consultas sejam executadas mais rapidamente ou como soluções alternativas para consultas que excedam os limites de recursos no Athena.
## Otimizar junções
Há muitas estratégias diferentes para executar junções em um mecanismo de consulta distribuído. Duas das mais comuns são as junções hash distribuídas e as consultas com condições de junção complexas.
### Em uma junção de hash distribuída, coloque tabelas grandes à esquerda e tabelas pequenas à direita
O tipo mais comum de junção usa uma comparação de igualdade como condição de junção. O Athena executa esse tipo de junção como uma junção hash distribuída.
Em uma junção hash distribuída, o mecanismo cria uma tabela de pesquisa (tabela hash) com base em um dos lados da junção. Esse lado é chamado de *lado da compilação*. Os registros do lado da compilação são distribuídos entre os nós. Cada nó cria uma tabela de pesquisa para o respectivo subconjunto. O outro lado da junção, denominado *lado de teste*, é então transmitido pelos nós. Os registros do lado de teste são distribuídos pelos nós da mesma forma que no lado da compilação. Isso permite que cada nó realize a junção pesquisando os registros correspondentes em sua própria tabela de pesquisa.
Quando as tabelas de pesquisa criadas do lado da compilação da junção não cabem na memória, as consultas podem falhar. Mesmo que o tamanho total do lado da compilação seja menor que a memória disponível, as consultas poderão falhar se a distribuição dos registros tiver uma distorção significativa. Em um caso extremo, todos os registros poderiam ter o mesmo valor para a condição de junção e caber na memória em um único nó. Mesmo uma consulta com menos distorção poderá falhar se um conjunto de valores for enviado ao mesmo nó e a soma dos valores ultrapassar a memória disponível. Os nós têm a capacidade de vazar registros para o disco, mas o vazamento retarda a execução da consulta e pode ser insuficiente para evitar que a consulta falhe.
O Athena tenta reordenar as junções para usar a relação maior como lado de teste e a relação menor como o lado da compilação. No entanto, por não gerenciar os dados em tabelas, o Athena tem informações limitadas e muitas vezes deve presumir que a primeira tabela é a maior e a segunda tabela é a menor.
Ao gravar junções com condições de junção baseadas em igualdade, suponha que a tabela à esquerda da palavra-chave `JOIN` seja o lado de teste e que a tabela à direita seja o lado da compilação. Verifique se a tabela direita, o lado da compilação, é a menor das tabelas. Se não for possível diminuir o lado da compilação da junção o suficiente para caber na memória, considere executar várias consultas que unam subconjuntos da tabela de compilação.
### Usar EXPLAIN para analisar consultas com junções complexas
Consultas com condições de junção complexas (por exemplo, consultas que usam `LIKE`, `>` ou outros operadores) geralmente demandam muito computacionalmente. Na pior das hipóteses, cada registro de um lado da junção deve ser comparado a todos os registros do outro lado da junção. Como o tempo de execução aumenta com o quadrado do número de registros, as consultas correm o risco de exceder o tempo máximo de execução.
Para descobrir como o Athena executará sua consulta com antecedência, você pode usar a instrução `EXPLAIN`. Para obter mais informações, consulte [Usar EXPLAIN e EXPLAIN ANALYZE no Athena](athena-explain-statement.md) e [Noções básicas dos resultados da instrução EXPLAIN do Athena](athena-explain-statement-understanding.md).
## Reduzir o escopo das funções da janela ou removê-las
Por serem operações que fazem uso intensivo de recursos, as funções de janela podem fazer com que as consultas sejam executadas lentamente ou até mesmo falhem com a mensagem Query exhausted resources at this scale factor. As funções de janela mantêm todos os registros em que operam na memória para calcular o resultado. Quando a janela é muito grande, a função de janela pode ficar sem memória.
Para garantir que suas consultas sejam executadas dentro dos limites de memória disponíveis, reduza o tamanho das janelas em que suas funções de janela operam. Para fazer isso, adicione uma cláusula `PARTITIONED BY` ou restrinja o escopo das cláusulas de particionamento existentes.
### Usar de funções que não são de janela
Às vezes, consultas com funções de janela podem ser gravadas sem funções de janela. Por exemplo, em vez de usar `row_number` para encontrar os principais registros `N`, você pode usar `ORDER BY` e `LIMIT`. Em vez de usar `row_number` ou `rank` para desduplicar registros, você pode usar funções agregadas como [max\$1by](https://trino.io/docs/current/functions/aggregate.html#max_by), [min\$1by](https://trino.io/docs/current/functions/aggregate.html#min_by) e [arbitrary](https://trino.io/docs/current/functions/aggregate.html#arbitrary).
Por exemplo, digamos que você tenha um conjunto de dados com atualizações de um sensor. O sensor informa periodicamente o status da bateria e inclui alguns metadados, como localização. Para saber o último status da bateria de cada sensor e sua localização, você pode usar esta consulta:
```
SELECT sensor_id,
arbitrary(location) AS location,
max_by(battery_status, updated_at) AS battery_status
FROM sensor_readings
GROUP BY sensor_id
```
Os metadados, como a localização, são os mesmos para cada registro, então você pode usar a função `arbitrary` para escolher qualquer valor do grupo.
Para obter o último status da bateria, você pode usar a função `max_by`. A função `max_by` escolhe o valor de uma coluna do registro em que o valor máximo de outra coluna foi encontrado. Nesse caso, ela retorna o status da bateria do registro com a hora da última atualização dentro do grupo. Essa consulta é executada mais rapidamente e usa menos memória do que uma consulta equivalente com função de janela.
## Otimizar agregações
Ao realizar uma agregação, o Athena distribui os registros entre os nós de processamento usando as colunas na cláusula `GROUP BY`. Para tornar a tarefa de combinar registros com grupos o mais eficiente possível, os nós tentam manter os registros na memória, mas os vazam para o disco, se necessário.
Também é uma boa ideia evitar incluir colunas redundantes nas cláusulas `GROUP BY`. Como menos colunas exigem menos memória, uma consulta que usa menos colunas para descrever um grupo é mais eficiente. As colunas numéricas também usam menos memória do que as strings. Por exemplo, ao agregar um conjunto de dados que tenha um ID numérico de categoria e um nome de categoria, use somente a coluna ID da categoria na cláusula `GROUP BY`.
Às vezes, as consultas incluem colunas na cláusula `GROUP BY` para contornar o fato de que uma coluna deve ser parte da cláusula `GROUP BY` ou ser uma expressão agregada. Se essa regra não for seguida, você poderá receber uma mensagem de erro como esta:
EXPRESSION\$1NOT\$1AGGREGATE: line 1:8: 'category' must be an aggregate expression or appear in GROUP BY clause
Para evitar a necessidade de adicionar colunas redundantes à cláusula `GROUP BY`, use a função [arbitrary](https://trino.io/docs/current/functions/aggregate.html#arbitrary), como no exemplo a seguir.
```
SELECT country_id,
arbitrary(country_name) AS country_name,
COUNT(*) AS city_count
FROM world_cities
GROUP BY country_id
```
A função `ARBITRARY` retorna um valor de arbitrary do grupo. A função é útil quando você sabe que todos os registros do grupo têm o mesmo valor para uma coluna, mas o valor não identifica o grupo.
## Otimizar as principais N consultas
A cláusula `ORDER BY` retorna os resultados de uma consulta em ordem de classificação. O Athena usa a classificação distribuída para executar a operação de classificação paralelamente em vários nós.
Se você não precisar estritamente que seu resultado seja classificado, evite adicionar uma cláusula `ORDER BY`. Além disso, evite adicionar `ORDER BY` a consultas internas se não for estritamente necessário. Em muitos casos, o planejador de consultas poderá remover a classificação redundante, mas isso não é garantido. Uma exceção a essa regra é se uma consulta interna estiver realizando uma operação principal `N`, como encontrar o `N` mais recente ou os valores de `N` mais comuns.
Quando o Athena vê `ORDER BY` junto com `LIMIT`, ele entende que você está executando uma consulta principal `N` e usa as operações dedicadas adequadamente.
**nota**
Embora o Athena muitas vezes também possa detectar funções de janela como `row_number` que usa `N` principal, recomendamos a versão mais simples que usa `ORDER BY` e `LIMIT`. Para obter mais informações, consulte [Reduzir o escopo das funções da janela ou removê-las](#performance-tuning-optimizing-window-functions).
## Incluir somente as colunas obrigatórias
Caso não precise estritamente de uma coluna, não a inclua na consulta. Quanto menos dados a consulta precisar processar, mais rápido ela será executada. Isso reduz a quantidade de memória necessária e a quantidade de dados que devem ser enviados entre os nós. Se você estiver usando um formato de arquivo colunar, reduzir o número de colunas também reduzirá a quantidade de dados lidos do Amazon S3.
O Athena não tem limite específico para o número de colunas de um resultado, mas a forma como as consultas são executadas limita o possível tamanho combinado das colunas. O tamanho combinado das colunas inclui os nomes e tipos.
Por exemplo, o seguinte erro é causado por uma relação que excede o limite de tamanho de um descritor de relação:
GENERIC\$1INTERNAL\$1ERROR: io.airlift.bytecode.CompilationException
Para resolver esse problema, reduza o número de colunas na consulta ou crie subconsultas e use `JOIN` para recuperar uma quantidade menor de dados. Se você tiver consultas que executam `SELECT *` na consulta mais externa, altere `*` para uma lista com somente as colunas necessárias.
## Otimizar consultas com o uso de aproximações
O Athena tem suporte para [funções agregadas de aproximação](https://trino.io/docs/current/functions/aggregate.html#appro) para contar valores distintos, valores mais frequentes, percentis (incluindo medianas aproximadas) e criar histogramas. Use essas funções sempre que não for necessário obter valores exatos.
Diferentemente das operações `COUNT(DISTINCT col)`, o [approx\$1distinct](https://trino.io/docs/current/functions/aggregate.html#approx_distinct) usa muito menos memória e é executado mais rápido. Da mesma forma, usar [numeric\$1histogram](https://trino.io/docs/current/functions/aggregate.html#numeric_histogram) em vez de [histogram](https://trino.io/docs/current/functions/aggregate.html#histogram) utiliza métodos aproximados e, portanto, menos memória.
## Otimizar LIKE
É possível usar `LIKE` para encontrar strings correspondentes, mas com strings longas, demanda uso intensivo de computação. Na maioria dos casos, a função [regexp\$1like](https://trino.io/docs/current/functions/regexp.html#regexp_like) é uma alternativa mais rápida e também oferece mais flexibilidade.
Muitas vezes, é possível otimizar uma pesquisa ancorando a substring que você está procurando. Por exemplo, se você estiver procurando por um prefixo, é muito melhor usar “*substr*%” em vez de “*substr*%”. Ou, se você estiver usando `regexp_like`, “^*substr*”.
## Usar UNION ALL em vez de UNION
`UNION ALL` e `UNION` são duas maneiras de combinar os resultados de duas consultas em um único resultado. `UNION ALL` concatena os registros da primeira consulta com a segunda e `UNION` faz o mesmo, mas também remove as duplicatas. `UNION` precisa processar todos os registros e encontrar as duplicatas, o que requer uso intensivo de memória e computação, mas `UNION ALL` é uma operação relativamente rápida. A menos que você precise desduplicar registros, use `UNION ALL` para obter a melhor performance.
## Usar UNLOAD para grandes conjuntos de resultados
Quando se espera que os resultados da consulta sejam grandes (por exemplo, dezenas de milhares de linhas ou mais), use UNLOAD para exportar os resultados. Na maioria dos casos, isso é mais rápido do que executar uma consulta normal, e usar `UNLOAD` também oferece mais controle sobre a saída.
Quando a consulta acaba de ser executada, o Athena armazena o resultado como um único arquivo CSV não compactado no Amazon S3. Isso leva mais tempo que usar `UNLOAD`, não apenas porque o resultado não está compactado, mas também porque a operação não pode ser paralelizada. Por sua vez, `UNLOAD` grava os resultados diretamente dos nós de trabalho e faz uso total do paralelismo do cluster de computação. Além disso, é possível configurar `UNLOAD` para gravar os resultados em formato compactado e em outros formatos de arquivo, como JSON e Parquet.
Para obter mais informações, consulte [UNLOAD](unload.md).
## Use CTAS ou o Glue ETL para materializar agregações usadas com frequência
“Materializar” uma consulta é uma forma de acelerar a performance da consulta armazenando resultados de consultas complexas pré-computados (por exemplo, agregações e junções) para reutilização em consultas subsequentes.
Se muitas de suas consultas incluírem as mesmas junções e agregações, você poderá materializar a subconsulta comum como uma nova tabela e executar consultas nessa tabela. É possível criar a nova tabela com [Criar uma tabela com base em resultados de consultas (CTAS)](ctas.md) ou com uma ferramenta ETL dedicada, como o [Glue ETL](https://aws.amazon.com/glue).
Por exemplo, digamos que você tenha um painel com widgets que exibem diferentes aspectos de um conjunto de dados de pedidos. Cada widget tem sua própria consulta, mas todas as consultas compartilham as mesmas junções e filtros. Uma tabela de pedidos é unida a uma tabela de itens de linha, e há um filtro para exibir somente os últimos três meses. Se você identificar os atributos comuns dessas consultas, poderá criar uma nova tabela que os widgets possam usar. Isso reduz a duplicação e melhora a performance. A desvantagem é que você deverá manter a nova tabela atualizada.
## Reutilizar resultados da consulta
É comum que a mesma consulta seja executada várias vezes em pouco tempo. Por exemplo, isso pode ocorrer quando várias pessoas abrem o mesmo painel de dados. Ao executar uma consulta, você pode pedir para o Athena reutilizar os resultados calculados anteriormente. Especifique a idade máxima dos resultados a serem reutilizados. Se a mesma consulta for executada anteriormente dentro desse período, o Athena retornará esses resultados em vez de executar a consulta novamente. Para obter mais informações, consulte [Reutilização de resultados da consulta no Athena](reusing-query-results.md) aqui no *Guia do usuário do Amazon Athena* e [Reduce cost and improve query performance with Amazon Athena Query Result Reuse](https://aws.amazon.com/blogs/big-data/reduce-cost-and-improve-query-performance-with-amazon-athena-query-result-reuse/) no *blog de big data da AWS*.
# Otimizar dados
A performance não depende apenas das consultas, mas também, principalmente, de como seu conjunto de dados está organizado e do formato de arquivo e da compactação que ele usa.
## Particionar dados
O particionamento divide a tabela em partes e mantém os dados relacionados juntos com base em propriedades como data, país ou região. As chaves de partição atuam como colunas virtuais. Você define as chaves de partição na criação da tabela e as utiliza para filtrar consultas. Quando você filtra as colunas das chaves de partição, somente os dados das partições correspondentes são lidos. Por exemplo, se o conjunto de dados estiver particionado por data e a consulta tiver um filtro que corresponda somente à última semana, somente os dados da última semana serão lidos. Para obter mais informações sobre particionamento, consulte [Particionar dados](partitions.md).
## Escolher chaves de partição que oferecerão suporte às suas consultas
Como o particionamento tem um impacto significativo na performance da consulta, pense com atenção em como você particionará ao criar seu conjunto de dados e tabelas. Ter muitas chaves de partição pode resultar em conjuntos de dados fragmentados com excesso de arquivos e arquivos muito pequenos. Por outro lado, ter poucas chaves de partição ou não ter particionamento leva a consultas que examinam mais dados do que o necessário.
### Evitar otimização de consultas raras
Uma boa estratégia é otimizar as consultas mais comuns e evitar a otimização de consultas raras. Por exemplo, se as consultas analisarem períodos de dias, não particione por hora, mesmo que algumas consultas sejam filtradas até esse nível. Se seus dados tiverem uma coluna de timestamp granular, as consultas raras que filtram por hora poderão usar a coluna de timestamp. Mesmo que casos raros verifiquem um pouco mais de dados do que o necessário, reduzir a performance geral em prol de casos raros geralmente não é vantajoso.
Para reduzir a quantidade de dados que as consultas precisam verificar e, assim, melhorar a performance, use um formato de arquivo colunar e mantenha os registros ordenados. Em vez de particionar por hora, mantenha os registros classificados por carimbo de data e hora. Para consultas em janelas de tempo mais curtas, a classificação por carimbo de data e hora é quase tão eficiente quanto a partição por hora. Além disso, a classificação por carimbo de data e hora normalmente não prejudica a performance das consultas nas janelas de tempo contadas em dias. Para obter mais informações, consulte [Usar formatos de arquivo colunares](#performance-tuning-use-columnar-file-formats).
As consultas em tabelas com dezenas de milhares de partições terão melhor performance se houver predicados em todas as chaves de partição. Esse é outro motivo para criar um esquema de particionamento para as consultas mais comuns. Para obter mais informações, consulte [Consultar partições por igualdade](#performance-tuning-query-partitions-by-equality).
## Usar projeção de partições
A projeção de partição é um atributo do Athena que armazena informações de partição não no AWS Glue Data Catalog, mas como regras nas propriedades da tabela no AWS Glue. Ao planejar uma consulta em uma tabela configurada com projeção de partição, o Athena lê as regras de projeção de partição da tabela. O Athena calcula as partições a serem lidas na memória com base na consulta e nas regras, em vez de procurar partições no AWS Glue Data Catalog.
Além de simplificar o gerenciamento de partições, a projeção de partições pode melhorar a performance de conjuntos de dados que têm um grande número de partições. Quando a consulta contém intervalos em vez de valores específicos para chaves de partição, a busca por partições correspondentes no catálogo demora mais quanto mais partições houver. Com a projeção de partição, o filtro pode ser computado na memória sem acessar o catálogo e pode ser muito mais rápido.
Em determinadas circunstâncias, a projeção de partições pode resultar em pior performance. Um exemplo ocorre quando uma tabela é “avulsa”. Uma tabela avulsa não tem dados para cada permutação dos valores da chave de partição descritos pela configuração da projeção da partição. Com uma tabela avulsa, o conjunto de partições calculado com base na consulta e a configuração da projeção da partição são listados no Amazon S3, mesmo quando não contêm dados.
Ao usar a projeção de partição, verifique se incluiu predicados em todas as chaves de partição. Limite o escopo dos valores possíveis para evitar listas desnecessárias do Amazon S3. Imagine uma chave de partição que contenha um intervalo de um milhão de valores e uma consulta que não tenha nenhum filtro nessa chave de partição. Para executar a consulta, o Athena deverá realizar pelo menos um milhão de operações de lista do Amazon S3. As consultas são mais rápidas quando você consulta valores específicos, independentemente de usar a projeção de partição ou armazenar informações de partição no catálogo. Para obter mais informações, consulte [Consultar partições por igualdade](#performance-tuning-query-partitions-by-equality).
Ao configurar uma tabela para projeção de partições, verifique se os intervalos especificados são razoáveis. Se a consulta não incluir um predicado em uma chave de partição, todos os valores no intervalo dessa chave serão usados. Se o conjunto de dados foi criado em uma data específica, use essa data como ponto de partida para qualquer intervalo de datas. Use `NOW` como fim de intervalos de datas. Evite intervalos numéricos que tenham um grande número de valores e considere usar o tipo [injected](partition-projection-dynamic-id-partitioning.md#partition-projection-injection) em vez disso.
Para obter mais informações sobre projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).
## Usar índices de partição
Os índices de partição são um atributo do AWS Glue Data Catalog que melhoram a performance da pesquisa de partições para tabelas que têm um grande número de partições.
A lista de partições do catálogo é como uma tabela em um banco de dados relacional. A tabela contém colunas para as chaves de partição e uma coluna adicional para o local da partição. Quando você consulta uma tabela particionada, os locais das partições são pesquisados por meio da verificação dessa tabela.
Assim como nos bancos de dados relacionais, é possível aumentar a performance das consultas adicionando índices. É possível adicionar vários índices para oferecer suporte a diferentes padrões de consulta. O índice de partição do AWS Glue Data Catalog é compatível com operadores de igualdade e comparação, como `>`, `>=` e `<` combinados com o operador `AND`. Para obter mais informações, consulte [Working with partition indexes in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) no *Guia do desenvolvedor do AWS Glue* e [Improve Amazon Athena query performance using AWS Glue Data Catalog partition indexes](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*.
## Use sempre STRING como o tipo para chaves de partição
Ao consultar chaves de partição, lembre-se de que o Athena exige que as chaves de partição sejam do tipo `STRING` para inserir a filtragem de partição no AWS Glue. Se o número de partições não for pequeno, usar outros tipos poderá reduzir a performance. Se os valores da chave de partição forem semelhantes a uma data ou a um número, converta-os ao tipo apropriado em sua consulta.
## Remover partições antigas e vazias
Se você remover dados de uma partição no Amazon S3 (por exemplo, usando o [ciclo de vida](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) do Amazon S3), também deverá remover a entrada da partição do AWS Glue Data Catalog. Durante o planejamento da consulta, toda partição correspondente à consulta é listada no Amazon S3. Se houver muitas partições vazias, a sobrecarga de listar essas partições poderá ser prejudicial.
Além disso, se houver milhares de partições, considere remover os metadados da partição de dados antigos que não são mais relevantes. Por exemplo, se as consultas nunca buscarem dados com mais de um ano, você poderá remover periodicamente os metadados das partições mais antigas. Se o número de partições aumentar para dezenas de milhares, remover partições não utilizadas pode acelerar as consultas que não incluem predicados em todas as chaves de partição. Para obter informações sobre como incluir predicados em todas as chaves de partição de suas consultas, consulte [Consultar partições por igualdade](#performance-tuning-query-partitions-by-equality).
## Consultar partições por igualdade
As consultas que contêm predicados de igualdade em todas as chaves de partição são executadas mais rapidamente porque os metadados da partição podem ser carregados diretamente. Evite consultas nas quais uma ou mais chaves de partição não tenham um predicado, ou o predicado seleciona uma faixa de valores. Para essas consultas, a lista de todas as partições deverá ser filtrada para encontrar valores correspondentes. Para a maioria das tabelas, a sobrecarga é mínima, mas para tabelas com dezenas de milhares de partições ou mais, a sobrecarga pode ser considerável.
Se não for possível gravar novamente suas consultas para filtrar partições por igualdade, você pode tentar a projeção de partições. Para obter mais informações, consulte [Usar projeção de partições](#performance-tuning-use-partition-projection).
## Evitar usar MSCK REPAIR TABLE para manutenção de partições
Como `MSCK REPAIR TABLE` pode levar muito tempo para ser executado, apenas adiciona novas partições e não remove partições antigas, não é uma forma eficiente de gerenciar partições (consulte [Considerações e limitações](msck-repair-table.md#msck-repair-table-considerations)).
É melhor gerenciar partições manualmente usando as [APIs do AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog.html), [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) ou [crawlers do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/crawler-running.html). Se preferir, você pode usar a projeção de partições, que elimina totalmente a necessidade de gerenciar as partições. Para obter mais informações, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).
## Verifique se suas consultas são compatíveis com o esquema de particionamento
É possível verificar com antecedência quais partições uma consulta examinará usando a instrução [`EXPLAIN`](athena-explain-statement.md). Prefixe sua consulta com a palavra-chave `EXPLAIN` e procure o fragmento de origem (por exemplo `Fragment 2 [SOURCE]`) para cada tabela na parte inferior da saída de `EXPLAIN`. Procure atribuições em que o lado direito esteja definido como chave de partição. A linha abaixo contém uma lista de todos os valores dessa chave de partição que serão verificados quando a consulta for executada.
Por exemplo, digamos que você tenha uma consulta em uma tabela com uma chave de partição `dt` e prefixe a consulta com `EXPLAIN`. Se os valores da consulta forem datas e um filtro selecionar um intervalo de três dias, a saída de `EXPLAIN` poderá ser mais ou menos assim:
```
dt := dt:string:PARTITION_KEY
:: [[2023-06-11], [2023-06-12], [2023-06-13]]
```
A saída de `EXPLAIN` mostra que o planejador encontrou três valores para essa chave de partição que corresponderam à consulta. Ela também mostra quais são esses valores. Para obter mais informações sobre o uso de `EXPLAIN`, consulte [Usar EXPLAIN e EXPLAIN ANALYZE no Athena](athena-explain-statement.md) e [Noções básicas dos resultados da instrução EXPLAIN do Athena](athena-explain-statement-understanding.md).
## Usar formatos de arquivo colunares
Formatos de arquivo colunar, como Parquet e ORC, foram criados para workloads de analytics distribuídas. Eles organizam os dados por coluna, não por linha. Organizar os dados em formato colunar oferece as seguintes vantagens:
+ Apenas as colunas necessárias para a consulta são carregadas
+ Reduz-se a quantidade geral de dados que precisam ser carregados
+ Os valores das colunas são armazenados juntos, de modo que os dados possam ser compactados com eficiência
+ Os arquivos podem conter metadados que permitam que o mecanismo ignore o carregamento de dados desnecessários
Como exemplo de como podemos usar os metadados do arquivo, os metadados do arquivo podem conter informações sobre os valores mínimo e máximo em uma página de dados. Se os valores consultados não estiverem no intervalo indicado nos metadados, a página poderá ser ignorada.
Uma forma de usar esses metadados para melhorar a performance é garantir que os dados dos arquivos sejam classificados. Por exemplo, digamos que você tenha consultas que buscam registros em que a entrada `created_at` esteja em um curto espaço de tempo. Se seus dados forem classificados pela coluna `created_at`, o Athena poderá usar os valores mínimo e máximo dos metadados do arquivo para ignorar as partes desnecessárias dos arquivos de dados.
Ao usar formatos de arquivo colunar, verifique se seus arquivos não são pequenos demais. Conforme observado em [Evite ter uma quantidade muito grande de arquivos](#performance-tuning-avoid-having-too-many-files), conjuntos de dados com muitos arquivos pequenos causam problemas de performance. Isso ocorre especialmente com formatos de arquivo colunar. Em arquivos pequenos, a sobrecarga do formato de arquivo colunar supera os benefícios.
O Parquet e o ORC são organizados internamente por grupos de linhas (Parquet) e faixas (ORC). O tamanho padrão para grupos de linhas é 128 MB, e para faixas, 64 MB. Se houver muitas colunas, você poderá aumentar o grupo de linhas e o tamanho da faixa para melhorar a performance. Não é recomendável diminuir o tamanho do grupo de linhas ou da faixa para um valor inferior ao padrão.
Para converter outros formatos de dados em Parquet ou ORC, você pode usar o AWS Glue ETL ou o Athena. Para obter mais informações, consulte [Converter em formatos colunares](columnar-storage.md#convert-to-columnar).
## Compactar dados
O Athena é compatível com uma ampla variedade de formatos de compactação. Consultar dados compactados é mais rápido e mais barato, pois você paga pelo número de bytes verificados antes da descompactação.
O formato [gzip](https://www.gnu.org/software/gzip/) fornece boas taxas de compactação e oferece amplo suporte a outras ferramentas e serviços. O formato [zstd](https://facebook.github.io/zstd/) (Zstandard) é um formato de compactação mais recente com um bom equilíbrio entre performance e taxa de compactação.
Ao compactar arquivos de texto, como dados JSON e CSV, tente chegar a um equilíbrio entre o número de arquivos e o tamanho dos arquivos. A maioria dos formatos de compactação exige que o leitor leia os arquivos desde o início. Isso significa que, em geral, os arquivos de texto compactados não podem ser processados em paralelo. Arquivos grandes não compactados muitas vezes são divididos entre operadores para obter maior paralelismo durante o processamento da consulta, mas isso não é possível com a maioria dos formatos de compactação.
Conforme discutido em [Evite ter uma quantidade muito grande de arquivos](#performance-tuning-avoid-having-too-many-files), é melhor não ter uma quantidade muito grande nem muito pequena de arquivos. Como o número de arquivos é o limite de quantos operadores podem processar a consulta, essa regra se aplica principalmente a arquivos compactados.
Para obter mais informações sobre uso de compactação no Athena, consulte [Usar compactação no Athena](compression-formats.md).
## Usar bucketing para pesquisas em chaves com alta cardinalidade
O bucketing é uma técnica para distribuir registros em arquivos separados com base no valor de uma das colunas. Isso garante que todos os registros com o mesmo valor estejam no mesmo arquivo. O bucketing é útil quando você tem uma chave com alta cardinalidade e muitas de suas consultas buscam valores específicos da chave.
Por exemplo, digamos que você consulte um conjunto de registros de um usuário específico. Se os dados forem agrupados em bucket por ID de usuário, o Athena saberá com antecedência quais arquivos contêm registros para um ID específico e quais não. Isso permite que o Athena leia somente os arquivos que possam conter o ID, reduzindo consideravelmente a quantidade de dados lidos. Também reduz o tempo de computação que, de outra forma, seria necessário para pesquisar os dados em busca do ID específico.
### Como evitar bucketing quando as consultas frequentemente pesquisam vários valores em uma coluna
O bucketing é menos vantajoso quando as consultas frequentemente pesquisam vários valores na coluna pela qual os dados são agrupados em bucket. Quanto mais valores forem consultados, maior será a probabilidade de que seja necessário ler todos ou a maioria dos arquivos. Por exemplo, se você tiver três buckets e uma consulta procurar três valores diferentes, talvez seja necessário ler todos os arquivos. O bucketing funciona melhor quando as consultas pesquisam valores únicos.
Para obter mais informações, consulte [Usar particionamento e bucketing](ctas-partitioning-and-bucketing.md).
## Evite ter uma quantidade muito grande de arquivos
Conjuntos de dados que consistem em muitos arquivos pequenos resultam em baixo desempenho geral da consulta. Ao planejar uma consulta, o Athena lista todos os locais das partições, o que leva tempo. O tratamento e a solicitação de cada arquivo também geram uma sobrecarga computacional. Portanto, é mais rápido carregar um único arquivo maior do Amazon S3 do que carregar os mesmos registros de muitos arquivos menores.
Em casos extremos, é possível encontrar limites de serviço do Amazon S3. O Amazon S3 é compatível com até 5.500 solicitações por segundo para uma única partição de índice. Inicialmente, o bucket é tratado como uma única partição de índice, mas à medida que as cargas de solicitações aumentam, ele pode ser dividido em várias partições de índice.
O Amazon S3 analisa os padrões de solicitação e as divisões com base nos prefixos de chave. Se seu conjunto de dados consistir em muitos milhares de arquivos, as solicitações provenientes do Athena poderão exceder a cota de solicitações. Mesmo com menos arquivos, a cota poderá ser excedida se forem feitas várias consultas simultâneas no mesmo conjunto de dados. Outras aplicações que acessam os mesmos arquivos podem contribuir para o número total de solicitações.
Quando o `limit` da taxa de solicitação é excedido, o Amazon S3 retorna o erro a seguir. Esse erro está incluído nas informações de status da consulta no Athena.
SlowDown: Please reduce your request rate
Para solucionar problemas, comece determinando se o erro foi causado por uma única consulta ou por várias consultas que leem os mesmos arquivos. No último caso, coordene a execução das consultas de modo que não sejam executadas ao mesmo tempo. Para obter isso, adicione um mecanismo de enfileiramento ou até mesmo novas tentativas em sua aplicação.
Se a execução de uma única consulta acionar o erro, tente combinar arquivos de dados ou modificar a consulta para ler menos arquivos. O melhor momento para combinar arquivos pequenos é antes de serem gravados. Para isso, considere as seguintes técnicas:
+ Altere o processo que grava arquivos para gravar arquivos maiores. Por exemplo, é possível armazenar registros em buffer por mais tempo antes de serem gravados.
+ Coloque arquivos em um local do Amazon S3 e use uma ferramenta como o Glue ETL para combiná-los em arquivos maiores. Em seguida, mova os arquivos maiores para o local ao qual a tabela aponta. Para obter mais informações, consulte [Reading input files in larger groups](https://docs.aws.amazon.com/glue/latest/dg/grouping-input-files.html) no *Guia do desenvolvedor do AWS Glue* ou [How can I configure an AWS Glue ETL job to output larger files?](https://repost.aws/knowledge-center/glue-job-output-large-files) no *Centro de Conhecimento AWS re:Post*.
+ Reduza o número de chaves de partição. Quando há muitas chaves de partição, cada partição pode ter poucos registros, resultando em um número excessivo de arquivos pequenos. Para obter informações sobre como decidir quais partições criar, consulte [Escolher chaves de partição que oferecerão suporte às suas consultas](#performance-tuning-pick-partition-keys-that-will-support-your-queries).
## Evitar hierarquias de armazenamento adicionais além da partição
Para evitar a sobrecarga do planejamento de consultas, armazene os arquivos em uma estrutura plana em cada local da partição. Não use hierarquias de diretório adicionais.
Ao planejar uma consulta, o Athena lista todos os arquivos em todas as partições correspondentes à consulta. Embora o Amazon S3 não tenha diretórios em si, a convenção é interpretar a barra direta `/` como separador de diretório. Ao listar os locais das partições, o Athena lista recursivamente qualquer diretório que encontrar. Quando os arquivos de uma partição são organizados em hierarquia, ocorrem várias rodadas de listagens.
Quando todos os arquivos estão diretamente no local da partição, na maioria das vezes, apenas uma operação de lista precisa ser executada. Porém, várias operações de lista sequencial serão necessárias se você tiver mais de mil arquivos em uma partição porque o Amazon S3 retorna somente mil objetos por operação de lista. Ter mais de mil arquivos em uma partição também pode criar outros problemas de performance mais graves. Para obter mais informações, consulte [Evite ter uma quantidade muito grande de arquivos](#performance-tuning-avoid-having-too-many-files).
## Use SymlinkTextInputFormat somente quando necessário
Usar a técnica [https://athena.guide/articles/stitching-tables-with-symlinktextinputformat](https://athena.guide/articles/stitching-tables-with-symlinktextinputformat) pode ser uma forma de resolver situações em que os arquivos da tabela não estão bem organizados em partições. Por exemplo, links simbólicos podem ser úteis quando todos os arquivos estão no mesmo prefixo ou quando há arquivos com esquemas diferentes no mesmo local.
Porém, usar links simbólicos adiciona níveis de indireção à execução da consulta. Esses níveis de indireção afetam a performance geral. Os arquivos de links simbólicos precisam ser lidos, e os locais que eles definem devem ser listados. Isso adiciona muitas viagens de ida e volta ao Amazon S3 que as tabelas habituais do Hive não exigem. Concluindo, você deverá usar `SymlinkTextInputFormat` somente quando não houver opções melhores disponíveis, como reorganizar arquivos.
# Usar formatos de armazenamento colunares
[Apache Parquet](https://parquet.apache.org) e [ORC](https://orc.apache.org/) são formatos de armazenamento colunar otimizados para recuperação rápida de dados usados em aplicações de análises da AWS.
Os formatos de armazenamento colunar têm as seguintes características que os tornam adequados para o uso com o Athena:
+ *Compactação por coluna, com algoritmo de compactação selecionado para o tipo de dados da coluna* para economizar espaço de armazenamento no Amazon S3 e reduzir E/S e espaço no disco durante o processamento de consultas.
+ A *aplicação de predicados* em Parquet e ORC permite que as consultas do Athena busquem somente os blocos de que precisa, melhorando a performance das consultas. Quando uma consulta do Athena obtém valores de coluna específicos dos seus dados, ela usa as estatísticas dos predicados de bloco de dados, como valores máximos e mínimos, para determinar se é para ler ou ignorar o bloco.
+ A *divisão de dados* em Parquet e ORC permite que o Athena divida a leitura de dados entre vários leitores e aumente o paralelismo durante o processamento da consulta.
Para converter seus dados brutos existentes de outros formatos de armazenamento em Parquet ou ORC, é possível executar consultas [CREATE TABLE AS SELECT (CTAS)](ctas.md) no Athena e especificar um formato de armazenamento de dados como Parquet ou ORC, ou usar o crawler do AWS Glue.
## Escolher entre Parquet e ORC
A escolha entre ORC (Optimized Row Columnar) e Parquet depende de seus requisitos específicos de uso.
O Apache Parquet fornece esquemas eficientes de compactação e codificação de dados e é ideal para executar consultas complexas e processar grandes quantidades de dados. O Parquet é otimizado para uso com o [Apache Arrow](https://arrow.apache.org/), o que pode ser vantajoso se você usar ferramentas relacionadas ao Arrow.
O ORC fornece uma maneira eficiente de armazenar dados do Hive. Os arquivos ORC geralmente são menores do que os arquivos Parquet, e os índices ORC podem agilizar as consultas. Além disso, o ORC é compatível com tipos complexos, como estruturas, mapas e listas.
Ao escolher entre Parquet e ORC, considere o seguinte:
**Desempenho da consulta**: o Parquet é compatível com uma variedade maior de tipos de consulta, por isso pode ser a melhor opção se você planeja realizar consultas complexas.
**Tipos de dados complexos**: se você estiver usando tipos de dados complexos, o ORC pode ser a melhor opção, porque ele é compatível com uma variedade maior de tipos de dados complexos.
**Tamanho do arquivo**: se o espaço em disco for uma preocupação, o ORC geralmente resulta em arquivos menores, o que pode reduzir os custos de armazenamento.
**Compactação**: tanto o Parquet quanto o ORC oferecem boa compactação, mas o melhor formato para você pode depender do seu caso específico de uso.
**Evolução**: tanto o Parquet quanto o ORC são compatíveis com uma evolução do esquema, o que significa que você pode adicionar, remover ou modificar colunas ao longo do tempo.
Tanto o Parquet quanto o ORC são boas opções para aplicações de big data, mas considere os requisitos do seu cenário antes de escolher. Talvez você queira realizar avaliações comparativas em seus dados e consultas para ver qual formato funciona melhor para seu caso de uso.
## Converter em formatos colunares
As opções para converter facilmente dados de origem, como JSON ou CSV, em um formato colunar, incluem o uso de consultas [CREATE TABLE AS](ctas.md) ou a execução de trabalhos no AWS Glue.
+ Você pode usar consultas (CTAS) `CREATE TABLE AS` para converter dados em Parquet ou ORC em uma única etapa. Para ver um exemplo, consulte [Exemplo: gravar resultados da consulta em um formato diferente](https://docs.aws.amazon.com/athena/latest/ug/ctas-examples.html#ctas-example-format) na página [Exemplos de consultas CTAS](ctas-examples.md).
+ Para obter informações sobre como usar o Athena para ETL para transformar dados de CSV em Parquet, consulte [Usar CTAS e INSERT INTO para ETL e análise de dados](ctas-insert-into-etl.md).
+ Para obter informações sobre como executar um trabalho do AWS Glue para transformar dados CSV em Parquet, consulte a seção “Transformar dados CSV em formato Parquet” na publicação [Construir a fundação de um data lake com o AWS Glue e o Amazon S3](https://aws.amazon.com/blogs/big-data/build-a-data-lake-foundation-with-aws-glue-and-amazon-s3/) no blog sobre big data da AWS. O AWS Glue oferece suporte à mesma técnica para converter dados CSV em ORC ou dados JSON em Parquet ou ORC.
# Usar particionamento e bucketing
O particionamento e o bucketing são duas formas de reduzir a quantidade de dados que o Athena deve verificar quando você executa uma consulta. O particionamento e o bucketing são complementares e podem ser usados em conjunto. Reduzir a quantidade de dados verificados gera uma performance melhor a um custo menor. Para obter diretrizes gerais sobre a performance das consultas do Athena, consulte [As dez melhores dicas de ajuste de performance para o Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
**Topics**
+ [
# O que é particionamento?
](ctas-partitioning-and-bucketing-what-is-partitioning.md)
+ [
# O que é bucketing?
](ctas-partitioning-and-bucketing-what-is-bucketing.md)
+ [
# Recursos adicionais
](ctas-partitioning-and-bucketing-additional-resources.md)
# O que é particionamento?
Particionamento significa organizar dados em diretórios (ou “prefixos”) no Amazon S3 com base em uma propriedade específica dos dados. Essas propriedades são chamadas chaves de partição. Uma chave de partição comum é a data ou alguma outra unidade de tempo, como ano ou mês. Porém, um conjunto de dados pode ser particionado por mais de uma chave. Por exemplo, dados sobre vendas de produtos podem ser divididos por data, categoria do produto e mercado.
## Decidir como particionar
Bons candidatos para chaves de partição são as propriedades que sempre ou quase sempre são usadas em consultas e têm baixa cardinalidade. Há um equilíbrio entre ter partições em excesso e não ter partições suficientes. Com partições em excesso, o aumento do número de arquivos cria sobrecarga. Também há sobrecarga na filtragem das partições em si. Com poucas partições, as consultas geralmente precisam verificar mais dados.
## Criar uma tabela particionada
Quando um conjunto de dados é particionado, é possível criar uma tabela particionada no Athena. Uma tabela particionada é uma tabela que contém chaves de partição. Ao usar `CREATE TABLE`, você adiciona partições à tabela. Quando você usa `CREATE TABLE AS`, as partições criadas no Amazon S3 são adicionadas automaticamente à tabela.
Em uma instrução `CREATE TABLE`, você especifica as chaves de partição na cláusula `PARTITIONED BY (column_name data_type)`. Em uma instrução `CREATE TABLE AS`, você especifica as chaves de partição em uma cláusula `WITH (partitioned_by = ARRAY['partition_key'])` ou `WITH (partitioning = ARRAY['partition_key'])` para tabelas Iceberg. Por questões de performance, as chaves de partição devem ser sempre do tipo `STRING`. Para obter mais informações, consulte [Usar string como o tipo de dados para chaves de partição](data-types-timestamps.md#data-types-timestamps-partition-key-types).
Para obter mais detalhes de sintaxe de `CREATE TABLE` e `CREATE TABLE AS`, consulte [CREATE TABLE](create-table.md) e [Propriedades da tabela CTAS](create-table-as.md#ctas-table-properties).
## Consultar tabelas particionadas
Quando você consulta uma tabela particionada, o Athena usa os predicados da consulta para filtrar a lista de partições. Em seguida, ele utiliza os locais das partições correspondentes para processar os arquivos encontrados. O Athena pode reduzir com eficiência a quantidade de dados verificados simplesmente não lendo dados nas partições que não correspondam aos predicados da consulta.
### Exemplos
Suponha que você tenha uma tabela particionada por `sales_date` e `product_category` e queira saber a receita total de uma semana em uma categoria específica. Inclua predicados nas colunas`sales_date` e `product_category` para garantir que o Athena verificará somente a quantidade mínima de dados, como no exemplo a seguir.
```
SELECT SUM(amount) AS total_revenue
FROM sales
WHERE sales_date BETWEEN '2023-02-27' AND '2023-03-05'
AND product_category = 'Toys'
```
Suponha que você tenha um conjunto de dados que seja particionado por data, mas também tenha um carimbo de data e hora refinado.
Com as tabelas Iceberg, é possível declarar que uma chave de partição tem uma relação com uma coluna, mas com as tabelas Hive, o mecanismo de consulta não tem conhecimento das relações entre colunas e chaves de partição. Por esse motivo, é necessário incluir um predicado na coluna e na chave de partição da consulta para garantir que a consulta não verifique mais dados do que o necessário.
Por exemplo, suponha que a tabela `sales` no exemplo anterior também tenha uma coluna `sold_at` do tipo de dados `TIMESTAMP`. Se você quiser somente a receita de um intervalo de tempo específico, escreva a consulta da seguinte forma:
```
SELECT SUM(amount) AS total_revenue
FROM sales
WHERE sales_date = '2023-02-28'
AND sold_at BETWEEN TIMESTAMP '2023-02-28 10:00:00' AND TIMESTAMP '2023-02-28 12:00:00'
AND product_category = 'Toys'
```
Para obter mais informações sobre a diferença entre consultar tabelas Hive e Iceberg, consulte [Como gravar consultas em campos de timestamp que também são particionados por tempo](data-types-timestamps.md#data-types-timestamps-how-to-write-queries-for-timestamp-fields-that-are-also-time-partitioned).
# O que é bucketing?
Bucketing é uma forma de organizar os registros de um conjunto de dados em categorias chamadas buckets.
Esse significado de bucket e bucketing é diferente dos buckets do Amazon S3 e não devem ser confundidos. No bucketing de dados, os registros que têm o mesmo valor para uma propriedade vão para o mesmo bucket. Os registros são distribuídos da forma mais uniforme possível entre os buckets, de modo que cada bucket tenha aproximadamente a mesma quantidade de dados.
Na prática, os buckets são arquivos, e uma função de hash determina o bucket em que um registro entrará. Um conjunto de dados em bucket terá um ou mais arquivos por bucket por partição. O bucket ao qual um arquivo pertence está codificado no nome do arquivo.
## Benefícios do bucketing
O bucketing é útil quando um conjunto de dados é classificado em bucket por determinada propriedade, e convém recuperar registros nos quais essa propriedade tenha determinado valor. Como os dados estão em buckets, o Athena pode usar o valor para determinar quais arquivos examinar. Por exemplo, suponha que um conjunto de dados esteja em buckets `customer_id` e você queira localizar todos os registros de um cliente específico. O Athena determina o bucket que contém os registros e lê somente os arquivos desse bucket.
Bons candidatos para bucketing ocorrem quando há colunas que têm alta cardinalidade (ou seja, com muitos valores distintos), estão uniformemente distribuídas e que você frequentemente consulta buscando valores específicos.
**nota**
O Athena não é compatível com o uso de `INSERT INTO` para adicionar novos registros a tabelas em bucket.
## Tipos de dados compatíveis com a filtragem em colunas em bucket
É possível adicionar filtros em colunas classificadas por buckets com determinados tipos de dados. O Athena permite essa filtragem nas colunas em bucket com os seguintes tipos de dados:
+ BOOLEAN
+ BYTE
+ DATE
+ DOUBLE
+ FLOAT
+ INT
+ LONG
+ SHORT
+ STRING
+ VARCHAR
## Compatível com Hive e Spark
O mecanismo Athena versão 2 é compatível com conjuntos de dados em buckets usando o algoritmo de bucket do Hive, e o mecanismo Athena versão 3 também é compatível com o algoritmo de bucketing do Apache Spark. O bucketing Hive é o padrão. Se seu conjunto de dados for classificado em buckets usando o algoritmo Spark, use a cláusula `TBLPROPERTIES` para definir o valor da propriedade `bucketing_format` como `spark`.
**nota**
O Athena tem um limite de 100 partições em uma consulta `CREATE TABLE AS SELECT` ([CTAS](ctas.md)). Da mesma forma, é possível adicionar apenas, no máximo, 100 partições a uma tabela de destino com uma instrução [INSERT INTO](insert-into.md).
Se exceder essa limitação, você poderá receber a mensagem de erro HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS: Exceeded limit of 100 open writers for partitions/buckets (Limite excedido de 100 gravadores abertos para partições/buckets). Para contornar essa limitação, é possível usar uma instrução CTAS e uma série de instruções `INSERT INTO` que criam ou inserem até 100 partições cada. Para obter mais informações, consulte [Usar CTAS e INSERT INTO para resolver o limite de 100 partições](ctas-insert-into.md).
## Exemplo de CREATE TABLE para bucketing
Para criar uma tabela para um conjunto de dados em buckets existente, use a cláusula `CLUSTERED BY (column)` seguida da cláusula `INTO N BUCKETS`. A cláusula `INTO N BUCKETS` especifica o número de buckets nos quais os dados são classificados.
No exemplo de `CREATE TABLE` a seguir, o conjunto de dados `sales` é classificado por `customer_id` em oito buckets usando o algoritmo Spark. A instrução `CREATE TABLE` usa as cláusulas`CLUSTERED BY` e `TBLPROPERTIES` para definir as propriedades adequadamente.
```
CREATE EXTERNAL TABLE sales (...)
...
CLUSTERED BY (`customer_id`) INTO 8 BUCKETS
...
TBLPROPERTIES (
'bucketing_format' = 'spark'
)
```
## Exemplo de CREATE TABLE AS (CTAS) para bucketing
Para especificar o bucketing com `CREATE TABLE AS`, use os parâmetros `bucketed_by` e `bucket_count`, como no exemplo a seguir.
```
CREATE TABLE sales
WITH (
...
bucketed_by = ARRAY['customer_id'],
bucket_count = 8
)
AS SELECT ...
```
## Exemplo de consulta de bucketing
O exemplo de consulta a seguir pesquisa os nomes dos produtos que um cliente específico comprou ao longo de uma semana.
```
SELECT DISTINCT product_name
FROM sales
WHERE sales_date BETWEEN '2023-02-27' AND '2023-03-05'
AND customer_id = 'c123'
```
Se essa tabela for particionada por `sales_date` e classificada em buckets por `customer_id`, o Athena poderá calcular o bucket em que os registros do cliente estão. No máximo, o Athena lê um arquivo por partição.
# Recursos adicionais
+ Para obter um exemplo de `CREATE TABLE AS` que cria tabelas em bucket e particionadas, consulte [Exemplo: criar tabelas em bucket e particionadas](https://docs.aws.amazon.com/athena/latest/ug/ctas-examples.html#ctas-example-bucketed).
+ Para obter informações sobre a implementação de buckets em data lakes do AWS, incluindo o uso de uma declaração CTAS do Athena, AWS Glue para o Apache Spark e buckets para tabelas do Apache Iceberg, consulte a postagem do blog do AWS Big Data: [Optimize data layout by bucketing with Amazon Athena and AWS Glue to accelerate downstream queries](https://aws.amazon.com/blogs/big-data/optimize-data-layout-by-bucketing-with-amazon-athena-and-aws-glue-to-accelerate-downstream-queries/).
# Particionar dados
Ao particionar os dados, você pode restringir a quantidade que cada consulta verifica, o que melhora a performance e reduz o custo. Você pode dividir seus dados em partições usando qualquer chave. Uma prática comum é particionar os dados com base no tempo, normalmente acarretando um esquema de particionamento em vários níveis. Por exemplo, um cliente que tenha dados vindos a cada hora pode optar por particionar por ano, mês, data e hora. Outro cliente, que tem dados oriundos de muitas origens diferentes, mas carregados apenas uma vez por dia, poderia particionar por um identificador de origem dos dados e data.
O Athena pode usar partições no estilo do Apache Hive, cujos caminhos de dados contêm pares de valor-chave conectados por sinais de igual (por exemplo, `country=us/...` ou `year=2021/month=01/day=26/...`). Assim, os caminhos incluem os nomes das chaves de partição e os valores que cada caminho representa. Para carregar novas partições Hive em uma tabela particionada, você pode usar o [MSCK REPAIR TABLE](msck-repair-table.md), que funciona apenas com partições no estilo Hive.
O Athena também pode usar esquemas de particionamento em estilo não Hive. Por exemplo, os logs do CloudTrail e os fluxos de entrega do Firehose usam componentes de caminho separados para componentes de data, como `data/2021/01/26/us/6fc7845e.json`. Para essas partições que não seguem o estilo do Hive, use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para adicionar as partições manualmente.
## Considerações e limitações
Ao usar o particionamento, lembre-se dos seguintes pontos:
+ Se você consultar uma tabela particionada e especificar a partição na cláusula `WHERE`, o Athena verificará somente os dados dessa partição.
+ Se você executar consultas em buckets do Amazon S3 com um grande número de objetos, e os dados não estiverem particionados, essas consultas poderão afetar os limites de taxa de solicitações `GET` no Amazon S3 e gerar exceções no Amazon S3. Para evitar erros, particione seus dados. Considere também ajustar suas taxas de solicitações do Amazon S3. Para obter mais informações, consulte [Padrões de design de melhores práticas: otimizar a performance do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/request-rate-perf-considerations.html).
+ Os locais das partições que serão usados com o Athena devem aplicar o protocolo do `s3` (por exemplo, `s3://amzn-s3-demo-bucket/folder/`). No Athena, os locais que usam outros protocolos (por exemplo, `s3a://amzn-s3-demo-bucket/folder/`) resultam em falhas nas consultas `MSCK REPAIR TABLE` quando elas são executadas nas tabelas que os contêm.
+ Verifique se o caminho do Amazon S3 está em letras minúsculas, em vez de maiúsculas e minúsculas concatenadas (por exemplo, `userid` em vez de `userId`). Se o caminho do S3 estiver em maiúsculas e minúsculas concatenadas, o `MSCK REPAIR TABLE` não adicionará as partições ao AWS Glue Data Catalog. Para obter mais informações, consulte [MSCK REPAIR TABLE](msck-repair-table.md).
+ Como `MSCK REPAIR TABLE` verifica uma pasta e as subpastas para encontrar um esquema de partição correspondente, mantenha os dados das tabelas separadas em hierarquias de pastas separadas. Por exemplo, suponha que você tenha dados na tabela 1 em `s3://amzn-s3-demo-bucket1` e dados na tabela 2 em `s3://amzn-s3-demo-bucket1/table-2-data`. Se ambas as tabelas forem particionadas por string, `MSCK REPAIR TABLE` adicionará as partições da tabela 2 à tabela 1. Para evitar isso, use estruturas de pastas separadas, como `s3://amzn-s3-demo-bucket1` e `s3://amzn-s3-demo-bucket2`. Observe que esse comportamento é consistente com o Amazon EMR e o Apache Hive.
+ Se estiver usando o AWS Glue Data Catalog com o Athena, consulte [Endpoints e cotas do AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html) para obter informações sobre cotas de serviço em partições por conta e por tabela.
+ Embora o Athena ofereça suporte a consulta a tabelas do AWS Glue com 10 milhões de partições, o Athena não pode ler mais de 1 milhão de partições em uma única varredura. Nesses cenários, a indexação de partições pode ser benéfica. Para obter mais informações, consulte o artigo do Blog de Big Data da AWS, [Melhorar a performance das consultas do Amazon Athena usando índices de partição do AWS Glue Data Catalog](https://aws.amazon.com/blogs/big-data/improve-amazon-athena-query-performance-using-aws-glue-data-catalog-partition-indexes/).
+ Para solicitar um aumento de cota de partições, se estiver usando o AWS Glue Data Catalog, acesse o [console do Service Quotas para o AWS Glue](https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/glue/quotas).
## Criar e carregar uma tabela com dados particionados
Para criar uma tabela que use partições, use a cláusula `PARTITIONED BY` na sua instrução [CREATE TABLE](create-table.md). A cláusula `PARTITIONED BY` define as chaves usadas para particionar dados, como no exemplo a seguir. A cláusula `LOCATION` especifica o local raiz dos dados particionados.
```
CREATE EXTERNAL TABLE users (
first string,
last string,
username string
)
PARTITIONED BY (id string)
STORED AS parquet
LOCATION 's3://amzn-s3-demo-bucket'
```
Depois de criar a tabela, carregue os dados nas partições para consulta. Para partições no estilo do Hive, você executa [MSCK REPAIR TABLE](msck-repair-table.md). Para partições que não seguem o estilo do Hive, use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para adicionar as partições manualmente.
## Preparar dados em estilo Hive e não Hive para consulta
As seções a seguir mostram como preparar dados de estilo do Hive e de estilo não Hive para consulta no Athena.
### Cenário 1: dados armazenados no Amazon S3 no formato Hive
Nesse cenário, as partições são armazenadas em pastas separadas no Amazon S3. Por exemplo, aqui está a listagem parcial para exemplos de impressões de anúncio exibidas pelo [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/ls.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/ls.html), que lista os objetos do S3 sob um prefixo especificado:
```
aws s3 ls s3://elasticmapreduce/samples/hive-ads/tables/impressions/
PRE dt=2009-04-12-13-00/
PRE dt=2009-04-12-13-05/
PRE dt=2009-04-12-13-10/
PRE dt=2009-04-12-13-15/
PRE dt=2009-04-12-13-20/
PRE dt=2009-04-12-14-00/
PRE dt=2009-04-12-14-05/
PRE dt=2009-04-12-14-10/
PRE dt=2009-04-12-14-15/
PRE dt=2009-04-12-14-20/
PRE dt=2009-04-12-15-00/
PRE dt=2009-04-12-15-05/
```
Aqui, os logs são armazenados com o nome da coluna (dt) definido igual a incrementos de data, hora e minuto. Quando especifica o local da pasta pai, o esquema e o nome da coluna particionada em uma DDL, o Athena pode consultar os dados nessas subpastas.
#### Criar a tabela
Para gerar uma tabela com esses dados, crie uma partição com “dt”, como na seguinte instrução DDL do Athena:
```
CREATE EXTERNAL TABLE impressions (
requestBeginTime string,
adId string,
impressionId string,
referrer string,
userAgent string,
userCookie string,
ip string,
number string,
processId string,
browserCookie string,
requestEndTime string,
timers struct,
threadId string,
hostname string,
sessionId string)
PARTITIONED BY (dt string)
ROW FORMAT serde 'org.apache.hive.hcatalog.data.JsonSerDe'
LOCATION 's3://elasticmapreduce/samples/hive-ads/tables/impressions/' ;
```
Esta tabela usa o serializador/desserializador JSON nativo do Hive para ler os dados JSON armazenados no Amazon S3. Para obter mais informações sobre os formatos compatíveis, consulte [Escolha de um SerDe para seus dados](supported-serdes.md).
#### Executar MSCK REPAIR TABLE
Depois de executar a consulta `CREATE TABLE`, execute o comando `MSCK REPAIR TABLE` no editor de consultas do Athena para carregar as partições, como no exemplo a seguir.
```
MSCK REPAIR TABLE impressions
```
Depois de executar esse comando, os dados estarão prontos para consulta.
#### Consultar os dados
Consulte os dados da tabela de impressões usando a coluna de partição. Veja um exemplo abaixo:
```
SELECT dt,impressionid FROM impressions WHERE dt<'2009-04-12-14-00' and dt>='2009-04-12-13-00' ORDER BY dt DESC LIMIT 100
```
Esta consulta deve mostrar dados semelhantes aos seguintes:
```
2009-04-12-13-20 ap3HcVKAWfXtgIPu6WpuUfAfL0DQEc
2009-04-12-13-20 17uchtodoS9kdeQP1x0XThKl5IuRsV
2009-04-12-13-20 JOUf1SCtRwviGw8sVcghqE5h0nkgtp
2009-04-12-13-20 NQ2XP0J0dvVbCXJ0pb4XvqJ5A4QxxH
2009-04-12-13-20 fFAItiBMsgqro9kRdIwbeX60SROaxr
2009-04-12-13-20 V4og4R9W6G3QjHHwF7gI1cSqig5D1G
2009-04-12-13-20 hPEPtBwk45msmwWTxPVVo1kVu4v11b
2009-04-12-13-20 v0SkfxegheD90gp31UCr6FplnKpx6i
2009-04-12-13-20 1iD9odVgOIi4QWkwHMcOhmwTkWDKfj
2009-04-12-13-20 b31tJiIA25CK8eDHQrHnbcknfSndUk
```
### Cenário 2: Os dados não são particionados no formato Hive
No exemplo a seguir, o comando `aws s3 ls` mostra os logs [ELB](elasticloadbalancer-classic-logs.md) armazenados no Amazon S3. Observe como o layout de dados não usa pares `key=value` e, portanto, não está no formato Hive. (A opção `--recursive` para o comando `aws s3 ls` especifica que todos os arquivos ou objetos no diretório ou prefixo especificado serão listados.)
```
aws s3 ls s3://athena-examples-myregion/elb/plaintext/ --recursive
2016-11-23 17:54:46 11789573 elb/plaintext/2015/01/01/part-r-00000-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:46 8776899 elb/plaintext/2015/01/01/part-r-00001-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:46 9309800 elb/plaintext/2015/01/01/part-r-00002-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:47 9412570 elb/plaintext/2015/01/01/part-r-00003-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:47 10725938 elb/plaintext/2015/01/01/part-r-00004-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:46 9439710 elb/plaintext/2015/01/01/part-r-00005-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:47 0 elb/plaintext/2015/01/01_$folder$
2016-11-23 17:54:47 9012723 elb/plaintext/2015/01/02/part-r-00006-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:47 7571816 elb/plaintext/2015/01/02/part-r-00007-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:47 9673393 elb/plaintext/2015/01/02/part-r-00008-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 11979218 elb/plaintext/2015/01/02/part-r-00009-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 9546833 elb/plaintext/2015/01/02/part-r-00010-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 10960865 elb/plaintext/2015/01/02/part-r-00011-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 0 elb/plaintext/2015/01/02_$folder$
2016-11-23 17:54:48 11360522 elb/plaintext/2015/01/03/part-r-00012-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 11211291 elb/plaintext/2015/01/03/part-r-00013-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:48 8633768 elb/plaintext/2015/01/03/part-r-00014-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:49 11891626 elb/plaintext/2015/01/03/part-r-00015-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:49 9173813 elb/plaintext/2015/01/03/part-r-00016-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:49 11899582 elb/plaintext/2015/01/03/part-r-00017-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:49 0 elb/plaintext/2015/01/03_$folder$
2016-11-23 17:54:50 8612843 elb/plaintext/2015/01/04/part-r-00018-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:50 10731284 elb/plaintext/2015/01/04/part-r-00019-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:50 9984735 elb/plaintext/2015/01/04/part-r-00020-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:50 9290089 elb/plaintext/2015/01/04/part-r-00021-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:50 7896339 elb/plaintext/2015/01/04/part-r-00022-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 8321364 elb/plaintext/2015/01/04/part-r-00023-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 0 elb/plaintext/2015/01/04_$folder$
2016-11-23 17:54:51 7641062 elb/plaintext/2015/01/05/part-r-00024-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 10253377 elb/plaintext/2015/01/05/part-r-00025-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 8502765 elb/plaintext/2015/01/05/part-r-00026-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 11518464 elb/plaintext/2015/01/05/part-r-00027-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 7945189 elb/plaintext/2015/01/05/part-r-00028-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 7864475 elb/plaintext/2015/01/05/part-r-00029-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 0 elb/plaintext/2015/01/05_$folder$
2016-11-23 17:54:51 11342140 elb/plaintext/2015/01/06/part-r-00030-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:51 8063755 elb/plaintext/2015/01/06/part-r-00031-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 9387508 elb/plaintext/2015/01/06/part-r-00032-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 9732343 elb/plaintext/2015/01/06/part-r-00033-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 11510326 elb/plaintext/2015/01/06/part-r-00034-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 9148117 elb/plaintext/2015/01/06/part-r-00035-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 0 elb/plaintext/2015/01/06_$folder$
2016-11-23 17:54:52 8402024 elb/plaintext/2015/01/07/part-r-00036-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 8282860 elb/plaintext/2015/01/07/part-r-00037-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:52 11575283 elb/plaintext/2015/01/07/part-r-00038-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:53 8149059 elb/plaintext/2015/01/07/part-r-00039-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:53 10037269 elb/plaintext/2015/01/07/part-r-00040-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:53 10019678 elb/plaintext/2015/01/07/part-r-00041-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt
2016-11-23 17:54:53 0 elb/plaintext/2015/01/07_$folder$
2016-11-23 17:54:53 0 elb/plaintext/2015/01_$folder$
2016-11-23 17:54:53 0 elb/plaintext/2015_$folder$
```
#### Executar ALTER TABLE ADD PARTITION
Como os dados não estão no formato Hive, você não pode usar o comando `MSCK REPAIR TABLE` para adicionar as partições à tabela depois de criá-la. Em vez disso, você pode usar o comando [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para adicionar cada partição manualmente. Por exemplo, para carregar os dados em s3://athena-examples-*myregion*/elb/plaintext/2015/01/01/, execute a consulta a seguir. Observe que não é necessária uma coluna de partição separada para cada pasta do Amazon S3 e que o valor da chave da partição pode ser diferente da chave do Amazon S3.
```
ALTER TABLE elb_logs_raw_native_part ADD PARTITION (dt='2015-01-01') location 's3://athena-examples-us-west-1/elb/plaintext/2015/01/01/'
```
Se já existir uma partição, você receberá o erro de que a partição já existe. Para evitar esse erro, você pode usar a cláusula `IF NOT EXISTS`. Para obter mais informações, consulte [ALTER TABLE ADD PARTITION](alter-table-add-partition.md). Para remover uma partição, use [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Considerar a projeção de partições
Para evitar a necessidade de gerenciar partições, é possível usar a projeção de partições. A projeção de partição é uma opção para tabelas altamente particionadas cuja estrutura é conhecida antecipadamente. Na projeção de partições, os valores e os locais das partições são calculados a partir das propriedades da tabela que foi configurada, não da leitura de um repositório de metadados. Como os cálculos na memória são mais rápidos do que a pesquisa remota, o uso da projeção de partição pode reduzir significativamente os tempos de execução da consulta.
Para obter mais informações, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).
## Recursos adicionais
+ Para obter informações sobre opções de particionamento para dados do Firehose, consulte [Exemplo do Amazon Data Firehose](partition-projection-kinesis-firehose-example.md).
+ Também é possível automatizar partições usando o [driver JDBC](connect-with-jdbc.md).
+ É possível usar CTAS e INSERT INTO para particionar um conjunto de dados. Para obter mais informações, consulte [Usar CTAS e INSERT INTO para ETL e análise de dados](ctas-insert-into-etl.md).
# Usar projeção de partições com o Amazon Athena
É possível usar a projeção de partições no Athena para acelerar o processamento de consultas de tabelas altamente particionadas e automatizar o gerenciamento de partições.
Na projeção de partições, o Athena calcula valores e localizações de partições usando as propriedades da tabela que você configura diretamente em sua tabela no AWS Glue. As propriedades da tabela permitem que o Athena “projete”, ou determine, as informações de partição necessárias em vez de fazer mais uma pesquisa de metadados demorada no AWS Glue Data Catalog. Como as operações na memória costumam ser mais rápidas do que as operações remotas, a projeção de partições pode reduzir o runtime de consultas em tabelas altamente particionadas. Dependendo das características específicas da consulta e dos dados subjacentes, a projeção de partições pode reduzir significativamente o runtime para consultas restritas na recuperação de metadados de partição.
## Noções básicas de remoção de partições versus a projeção de partições
A redução de partição coleta metadados e os “reduz” para apenas as partições que se aplicam à sua consulta. Geralmente, isso acelera as consultas. O Athena usa a redução de partição em todas as tabelas com colunas de partição, inclusive aquelas configuradas para projeção de partições.
Normalmente, ao processar consultas, o Athena faz uma chamada `GetPartitions` para o AWS Glue Data Catalog antes de reduzir a partição. Se uma tabela tiver um grande número de partições, o uso de `GetPartitions` poderá prejudicar a performance. Para que isso não aconteça, você pode usar a projeção de partições. A projeção de partições permite que o Athena evite chamar `GetPartitions` porque a configuração de projeção de partições fornece ao Athena todas as informações necessárias para criar as partições propriamente ditas.
## Usar projeção de partições
Para usar a projeção de partições, especifique os intervalos de valores de partição e os tipos de projeção para cada coluna de partição nas propriedades da tabela no AWS Glue Data Catalog ou no [metastore do Hive externo](connect-to-data-source-hive.md). Essas propriedades personalizadas na tabela permitem que o Athena saiba quais padrões de partição esperar ao executar uma consulta na tabela. Durante a execução da consulta, o Athena usa essas informações para projetar os valores de partição, em vez de recuperá-los do AWS Glue Data Catalog ou do metastore do Hive externo. Esse comportamento reduz o tempo de execução da consulta e também automatiza o gerenciamento de partições, pois acaba com a necessidade de criar manualmente partições no Athena, no AWS Glue ou no metastore do Hive externo.
**Importante**
Habilitar a projeção de partições em uma tabela faz com que o Athena ignore os metadados de partição registrados na tabela no AWS Glue Data Catalog ou no metastore do Hive.
## Alguns casos de uso
Os cenários em que a projeção de partições é útil incluem o seguinte:
+ As consultas em uma tabela altamente particionada não são concluídas com a rapidez desejada.
+ Você adiciona partições regularmente a tabelas à medida que novas partições de data ou hora são criadas em seus dados. Com a projeção de partições, você configura intervalos de datas relativos que podem ser usados à medida que novos dados chegam.
+ Você tem dados altamente particionados no Amazon S3. Os dados não são práticos para modelar no AWS Glue Data Catalog ou no metastore do Hive, e suas consultas leem apenas pequenas partes deles.
### Estruturas de partições projetáveis
A projeção de partições é mais facilmente configurada quando as partições seguem um padrão previsível como, mas não limitado ao seguinte:
+ **Inteiros**: qualquer sequência contínua de inteiros, como `[1, 2, 3, 4, ..., 1000]` ou `[0500, 0550, 0600, ..., 2500]`.
+ **Datas**: qualquer sequência contínua de datas ou datas e horas, como `[20200101, 20200102, ..., 20201231]` ou `[1-1-2020 00:00:00, 1-1-2020 01:00:00, ..., 12-31-2020 23:00:00]`.
+ **Valores enumerados**: um conjunto finito de valores enumerados, como códigos de aeroporto ou Regiões da AWS.
+ **Logs de AWS service (Serviço da AWS)**: normalmente, os logs de AWS service (Serviço da AWS) têm uma estrutura conhecida com um esquema de partição que você pode especificar no AWS Glue e que, portanto, o Athena pode usar na projeção de partições.
### Como personalizar o modelo de caminho de partição
Por padrão, o Athena cria locais de partição usando o formulário `s3://amzn-s3-demo-bucket//partition-col-1=/partition-col-2=/`. No entanto, se os dados estão organizados de forma diferente, o Athena oferece um mecanismo para personalizar esse modelo de caminho. Para obter as etapas, consulte [Como especificar locais de armazenamento personalizados do S3](partition-projection-setting-up.md#partition-projection-specifying-custom-s3-storage-locations).
## Considerações e limitações
As seguintes considerações se aplicam:
+ A projeção de partições elimina a necessidade de especificar partições manualmente no AWS Glue ou em um metastore do Hive externo.
+ Quando você habilita a projeção de partições em uma tabela, o Athena ignora todos os metadados de partição no AWS Glue Data Catalog ou no metastore do Hive externo referentes a essa tabela.
+ Se uma partição projetada não existir no Amazon S3, o Athena ainda a projetará. O Athena não gera um erro, mas também não retorna dados. No entanto, se muitas partições estiverem vazias, a performance poderá ser mais lenta em comparação com as partições tradicionais do AWS Glue. Se mais da metade das partições projetadas estiver vazia, é recomendado usar partições tradicionais.
+ As consultas de valores que excedem os limites de intervalo definidos para a projeção de partição não retornam erro. Em vez disso, a consulta é executada, mas não retorna nenhuma linha. Por exemplo, se você tem dados relacionados a um cronograma que começa em 2020 e está definidos como `'projection.timestamp.range'='2020/01/01,NOW'`, uma consulta como `SELECT * FROM table-name WHERE timestamp = '2019/02/02'` será concluída com êxito, mas não retornará nenhuma linha.
+ A projeção de partições somente pode ser usada quando a tabela é consultada pelo Athena. Se a mesma tabela for lida por meio de outro serviço, como o Amazon Redshift Spectrum, o Athena for Spark ou o Amazon EMR, os metadados de partição padrão serão usados.
+ Como a projeção de partições é um recurso somente DML, `SHOW PARTITIONS` não lista as partições projetadas pelo Athena, mas que não estão registradas no catálogo do AWS Glue ou no metastore do Hive externo.
+ O Athena não usa as propriedades de tabela de visualizações como configuração para a projeção de partições. Para contornar essa limitação, configure e habilite a projeção de partições nas propriedades das tabelas mencionadas nas visualizações.
## Vídeo
O vídeo a seguir mostra como usar a projeção de partições para melhorar a performance das suas consultas no Athena.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/iUD5pPpcyZk)
**Topics**
+ [
## Noções básicas de remoção de partições versus a projeção de partições
](#partition-projection-pruning-vs-projection)
+ [
## Usar projeção de partições
](#partition-projection-using)
+ [
## Alguns casos de uso
](#partition-projection-use-cases)
+ [
## Considerações e limitações
](#partition-projection-considerations-and-limitations)
+ [
## Vídeo
](#partition-projection-video)
+ [
# Configurar a projeção de partições
](partition-projection-setting-up.md)
+ [
# Tipos compatíveis para projeção de partições
](partition-projection-supported-types.md)
+ [
# Usar particionamento de ID dinâmico
](partition-projection-dynamic-id-partitioning.md)
+ [
# Exemplo do Amazon Data Firehose
](partition-projection-kinesis-firehose-example.md)
# Configurar a projeção de partições
A configuração da projeção de partições nas propriedades de uma tabela é um processo de duas etapas:
1. Especifique os intervalos de dados e os padrões relevantes para cada coluna de partição ou use um modelo personalizado.
1. Habilite a projeção de partições para a tabela.
**nota**
Antes de adicionar propriedades de projeção de partição para uma tabela existente, a coluna de partição para a qual você está configurando as propriedades de projeção de partição já deve existir no esquema da tabela. Caso a coluna de partição ainda não exista, você deverá adicionar manualmente uma coluna de partição à tabela existente. O AWS Glue não executa esta etapa para você de forma automática.
Esta seção mostra como definir as propriedades de tabela para o AWS Glue. Para defini-las, você pode usar o console do AWS Glue, as consultas [CREATE TABLE](create-table.md) do Athena ou as operações de [AWS Glue API](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api.html). O procedimento a seguir mostra como definir as propriedades no console do AWS Glue.
**Para configurar e habilitar a projeção de partições 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. Escolha a guia **Tabelas**.
Na guia **Tabelas**, você pode editar tabelas existentes ou escolher **Adicionar tabelas** para criar novas tabelas. Para obter informações sobre como adicionar tabelas manualmente ou com um crawler, consulte [Trabalhar com tabelas no console do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) no *Guia do desenvolvedor do AWS Glue*.
1. Na lista de tabelas, escolha o link para a tabela que você deseja editar.
![\[No console do AWS Glue, escolha uma tabela para editar.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/partition-projection-1.png)
1. Selecione **Actions** (Ações), **Edit** (Editar).
1. Na página **Edit table** (Editar tabela), na seção **Table properties** (Propriedades da tabela), para cada coluna particionada, adicione o seguinte par de chave-valor:
1. Em **Chave**, adicione `projection.columnName.type`.
1. Em **Valor**, adicione um dos tipos compatíveis: `enum`, `integer`, `date` ou `injected`. Para obter mais informações, consulte [Tipos compatíveis para projeção de partições](partition-projection-supported-types.md).
1. Seguindo as orientações em [Tipos compatíveis para projeção de partições](partition-projection-supported-types.md), adicione outros pares de chave-valor de acordo com seus requisitos de configuração.
O exemplo de configuração de tabela a seguir configura a coluna `year` para projeção de partições, restringindo os valores que podem ser retornados a um intervalo de 2010 a 2016.
![\[Configuração da projeção de partições para uma coluna de partição nas propriedades de tabela do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/partition-projection-3.png)
1. Adicione um par de chave-valor para habilitar a projeção de partições. Em **Chave**, insira `projection.enabled` e, em **Valor**, insira `true`.
**nota**
Você pode desativar a projeção de partições nessa tabela a qualquer momento definindo `projection.enabled` como `false`.
1. Quando terminar, escolha **Salvar**.
1. No editor de consultas do Athena, faça uma consulta de teste nas colunas de tabela que você configurou.
A consulta de exemplo a seguir usa `SELECT DISTINCT` para retornar os valores exclusivos da coluna `year`. O banco de dados contém dados de 1987 a 2016, mas a propriedade `projection.year.range` restringe os valores retornados para os anos 2010 a 2016.
![\[Consultando uma coluna que usa projeção de partições.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/partition-projection-5.png)
**nota**
Se você definir `projection.enabled` como `true`, mas não conseguir configurar uma ou mais colunas de partição, receberá uma mensagem de erro como a seguinte:
`HIVE_METASTORE_ERROR: Table database_name.table_name is configured for partition projection, but the following partition columns are missing projection configuration: [column_name] (table database_name.table_name)`.
## Como especificar locais de armazenamento personalizados do S3
Ao editar as propriedades de tabela no AWS Glue, você também pode especificar um modelo de caminho do Amazon S3 personalizado para as partições projetadas. Um modelo personalizado permite que o Athena mapeie corretamente os valores de partição para os locais de arquivo personalizados do Amazon S3 que não seguem o padrão `.../column=value/...`.
O uso de um modelo personalizado é opcional. No entanto, se você usar um modelo personalizado, o modelo deverá conter um espaço reservado para cada coluna de partição. Os locais baseados em modelo devem terminar com uma barra para que os arquivos de dados particionados sejam armazenados em uma “pasta” por partição.
**Como especificar um modelo de local de partição personalizado**
1. Seguindo as etapas para [configurar e habilitar a projeção de partições usando o console do AWS Glue](#partition-projection-setting-up-procedure), adicione outro par de chave-valor que especifique um modelo personalizado da seguinte forma:
1. Em **Chave**, digite `storage.location.template`.
1. Em **Valor**, especifique um local que inclua um espaço reservado para cada coluna de partição. Termine cada espaço reservado (e o próprio caminho do S3) com uma barra única.
Os valores de modelo de exemplo a seguir assumem uma tabela com colunas de partição `a`, `b` e `c`.
```
s3://amzn-s3-demo-bucket/table_root/a=${a}/${b}/some_static_subdirectory/${c}/
```
```
s3://amzn-s3-demo-bucket/table_root/c=${c}/${b}/some_static_subdirectory/${a}/${b}/${c}/${c}/
```
Para a mesma tabela, o valor de modelo de exemplo a seguir é inválido porque não contém nenhum espaço reservado para a coluna `c`.
```
s3://amzn-s3-demo-bucket/table_root/a=${a}/${b}/some_static_subdirectory/
```
1. Escolha **Aplicar**.
# Tipos compatíveis para projeção de partições
Uma tabela pode ter qualquer combinação dos tipos `enum`, `integer`, `date,` ou `injected` de coluna de partição.
## Tipo enum
Use o tipo `enum` para colunas de partição cujos valores são membros de um conjunto enumerado (por exemplo, códigos de aeroporto ou Regiões da AWS).
Defina as propriedades da partição na tabela da seguinte forma:
****
| Nome da propriedade | Exemplos de valores | Descrição |
| --- | --- | --- |
| projection.columnName.type | `enum` | Obrigatório. O tipo de projeção a ser usado para a coluna columnName. O valor deve ser enum (sem diferenciar maiúsculas e minúsculas) para sinalizar o uso do tipo de enumeração. Espaços em branco iniciais e finais são permitidos. |
| projection.columnName.values | `A,B,C,D,E,F,G,Unknown` | Obrigatório. Uma lista separada por vírgulas de valores de partição enumerados para a coluna columnName. Qualquer espaço em branco é considerado parte de um valor de enumeração. |
**nota**
Como prática recomendada, limite o uso de projeções de partições com base em `enum` a no máximo algumas dúzias. Embora não haja um limite específico para projeções `enum`, o tamanho total dos metadados da sua tabela não pode exceder o limite do AWS Glue de cerca de 1 MB quando compactado com gzip. Esse limite é compartilhado entre as partes principais da tabela, como nomes de colunas, local, formato de armazenamento etc. Se você usar mais de algumas dúzias de IDs exclusivos em sua projeção `enum`, considere uma abordagem alternativa, como criar buckets de um número menor de valores exclusivos em um campo substituto. Ao compensar a cardinalidade, você pode controlar o número de valores exclusivos no campo `enum`.
## Tipo integer
Use o tipo integer para colunas de partição cujos valores possíveis são interpretáveis como inteiros dentro de um intervalo definido. As colunas integer projetadas estão atualmente limitadas ao intervalo de um Java assinado longo (-263 a 263-1, ambos incluídos).
****
| Nome da propriedade | Exemplos de valores | Descrição |
| --- | --- | --- |
| projection.columnName.type | `integer` | Obrigatório. O tipo de projeção a ser usado para a coluna columnName. O valor deve ser integer (sem diferenciar maiúsculas e minúsculas) para sinalizar o uso do tipo de inteiro. Espaços em branco iniciais e finais são permitidos. |
| projection.columnName.range | `0,10` `-1,8675309` `0001,9999` | Obrigatório. Uma lista separada por vírgulas de dois elementos que fornece os valores de intervalo mínimo e máximo a serem retornados por consultas na coluna columnName. Observe que os valores devem ser separados por uma vírgula, não por um hífen. Esses valores são inclusivos, podem ser negativos e podem ter zeros à esquerda. Espaços em branco iniciais e finais são permitidos. |
| projection.columnName.interval | `1` `5` | Opcional. Um inteiro positivo que especifica o intervalo entre valores de partição sucessivos para a coluna columnName. Por exemplo, um valor range de “1,3" com um valor interval de “1" produz os valores 1, 2 e 3. O mesmo valor range com um valor interval de “2" produz os valores 1 e 3, ignorando 2. Espaços em branco iniciais e finais são permitidos. O padrão é 1. |
| projection.columnName.digits | `1` `5` | Opcional. Um inteiro positivo que especifica o número de dígitos a serem incluídos na representação final do valor da partição para a coluna columnName. Por exemplo, um valor range de “1,3" que tem um valor digits de “1" produz os valores 1, 2 e 3. O mesmo valor range com um valor digits de “2" produz os valores 01, 02 e 03. Espaços em branco iniciais e finais são permitidos. O padrão é nenhum número estático de dígitos e nenhum zero à esquerda. |
## Tipo date
Use o tipo date para colunas de partição cujos valores são interpretáveis como datas (com horas opcionais) dentro de um intervalo definido.
**Importante**
As colunas date projetadas são geradas no Horário Universal Coordenado (UTC) no tempo de execução da consulta.
****
| Nome da propriedade | Exemplos de valores | Descrição |
| --- | --- | --- |
| projection.columnName.type | `date` | Obrigatório. O tipo de projeção a ser usado para a coluna columnName. O valor deve ser date (sem diferenciar maiúsculas e minúsculas) para sinalizar o uso do tipo de data. Espaços em branco iniciais e finais são permitidos. |
| projection.columnName.range | `201701,201812` `01-01-2010,12-31-2018` `NOW-3YEARS,NOW` `201801,NOW+1MONTH` | Obrigatório. Uma lista separada por vírgulas de dois elementos que fornece os valores `range` mínimo e máximo para a coluna *columnName*. Esses valores são inclusivos e podem usar qualquer formato compatível com os tipos de data `java.time.*` em Java. Os valores mínimo e máximo devem usar o mesmo formato. O formato especificado na propriedade `.format` deve ser o formato usado para esses valores. Essa coluna também pode conter strings de data relativas, formatadas neste padrão de expressão regular: `\s*NOW\s*(([\+\-])\s*([0-9]+)\s*(YEARS?\|MONTHS?\|WEEKS?\|DAYS?\|HOURS?\|MINUTES?\|SECONDS?)\s*)?` Espaços em branco são permitidos. No entanto, em literais de data, eles são considerados parte das strings de data em si. |
| projection.columnName.format | `yyyyMM` `dd-MM-yyyy` `dd-MM-yyyy-HH-mm-ss` | Obrigatório. Uma string de formato de data baseada no formato de data Java [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html). Pode ser qualquer tipo Java.time.\$1 compatível. |
| projection.columnName.interval | `1` `5` | Um inteiro positivo que especifica o intervalo entre valores de partição sucessivos para a coluna *columnName*. Por exemplo, um valor `range` de `2017-01,2018-12` com um valor `interval` de `1` e um valor `interval.unit` de `MONTHS` produz os valores 2017-01, 2017-02, 2017-03 e assim por diante. O mesmo valor `range` com um valor `interval` de `2` e um valor `interval.unit` de `MONTHS` produz os valores 2017-01, 2017-03, 2017-05 e assim por diante. Espaços em branco iniciais e finais são permitidos. Quando as datas fornecidas são com precisão de um dia ou um mês, o `interval` é opcional e o padrão é 1 dia ou 1 mês, respectivamente. Caso contrário, o `interval` será obrigatório. |
| projection.columnName.interval.unit | `YEARS` `MONTHS` `WEEKS` `DAYS` `HOURS` `MINUTES` `SECONDS` `MILLIS` | Uma palavra de unidade de tempo que representa a forma serializada de uma [ChronoUnit](https://docs.oracle.com/javase/8/docs/api/java/time/temporal/ChronoUnit.html). Os valores possíveis são `YEARS`, `MONTHS`, `WEEKS`, `DAYS`, `HOURS`, `MINUTES`, `SECONDS` ou `MILLIS`. Esses valores diferenciam maiúsculas de minúsculas. Quando as datas fornecidas são com precisão de um dia ou um mês, o `interval.unit` é opcional e o padrão é 1 dia ou 1 mês, respectivamente. Caso contrário, `interval.unit` será obrigatório. |
**Example - Particionamento por mês**
O exemplo de configuração da tabela a seguir particiona os dados por mês, de 2015 até o presente.
```
'projection.month.type'='date',
'projection.month.format'='yyyy-MM',
'projection.month.interval'='1',
'projection.month.interval.unit'='MONTHS',
'projection.month.range'='2015-01,NOW',
...
```
## Tipo injected
Use o tipo injetado para colunas de partição com valores possíveis que não podem ser gerados processualmente dentro de algum intervalo lógico, mas que são fornecidos na cláusula `WHERE` de uma consulta como um único valor.
É importante ter em mente os seguintes pontos:
+ Consultas em colunas injetadas falharão se uma expressão de filtro não for fornecida para cada coluna injetada.
+ Consultas com vários valores para uma expressão de filtro em uma coluna injetada só terão êxito se os valores forem disjuntos.
+ Somente colunas do tipo `string` são permitidas.
+ Quando você usa a cláusula `WHERE IN` com uma coluna de partição injetada, há um limite de 1.000 valores que podem ser especificados na lista `IN`. Para consultar um conjunto de dados com mais de 1.000 partições para uma coluna injetada, divida a consulta em várias consultas menores, cada uma com até 1.000 valores na cláusula `WHERE IN`, e, em seguida, agregue os resultados.
****
| Nome da propriedade | Valor | Descrição |
| --- | --- | --- |
| projection.columnName.type | `injected` | Obrigatório. O tipo de projeção a ser usado para a coluna columnName. Somente o tipo string é permitido. O valor especificado deve ser injected (sem diferenciação de maiúsculas e minúsculas). Espaços em branco iniciais e finais são permitidos. |
Para obter mais informações, consulte [Quando usar o tipo de projeção `injected`](partition-projection-dynamic-id-partitioning.md#partition-projection-injection).
# Usar particionamento de ID dinâmico
Quando os dados são particionados por uma propriedade com alta cardinalidade ou quando os valores não podem ser conhecidos antecipadamente, é possível usar o tipo de projeção `injected`. Exemplos dessas propriedades são os nomes de usuário e os IDs de dispositivos ou de produtos. Quando você usa o tipo de projeção `injected` para configurar uma chave de partição, o Athena usa valores da própria consulta para calcular o conjunto de partições que serão lidas.
Para que o Athena possa executar uma consulta em uma tabela que tem uma chave de partição configurada com o tipo de projeção `injected`, o seguinte deve ser verdadeiro:
+ A consulta deve incluir, no mínimo, um valor para a chave de partição.
+ Os valores devem ser literais ou expressões que possam ser avaliadas sem a necessidade de leitura de dados.
Se algum desses critérios não for atendido, a consulta falhará e apresentará o seguinte erro:
CONSTRAINT\$1VIOLATION: para a coluna de partição projetada injetada *column\$1name*, a cláusula WHERE deve conter somente condições de igualdade estática e pelo menos uma dessas condições deve estar presente.
## Quando usar o tipo de projeção `injected`
Imagine que você tem um conjunto de dados que consiste em eventos de dispositivos de IoT, os quais são particionados nos IDs dos dispositivos. Esse conjunto de dados tem as seguintes características:
+ Os IDs dos dispositivos são gerados de forma aleatória.
+ Novos dispositivos são provisionados com frequência.
+ Atualmente, existem centenas de milhares de dispositivos e, no futuro, haverá milhões.
Esse conjunto de dados é complexo de gerenciar usando metastores tradicionais. É difícil manter as partições sincronizadas entre o armazenamento de dados e o metastore, e a filtragem de partições pode ser lenta durante o planejamento da consulta. Entretanto, se você configurar uma tabela para usar a projeção de partição e usar o tipo de projeção `injected`, obterá duas vantagens: não precisará gerenciar partições no metastore e as consultas não precisarão procurar metadados de partições.
O exemplo `CREATE TABLE`, apresentado a seguir, cria uma tabela para o conjunto de dados de eventos do dispositivo que acabamos de descrever. A tabela usa o tipo de projeção “injected”.
```
CREATE EXTERNAL TABLE device_events (
event_time TIMESTAMP,
data STRING,
battery_level INT
)
PARTITIONED BY (
device_id STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.device_id.type" = "injected",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${device_id}"
)
```
O exemplo de consulta apresentado a seguir pesquisa o número de eventos recebidos de três dispositivos específicos ao longo de 12 horas.
```
SELECT device_id, COUNT(*) AS events
FROM device_events
WHERE device_id IN (
'4a770164-0392-4a41-8565-40ed8cec737e',
'f71d12cf-f01f-4877-875d-128c23cbde17',
'763421d8-b005-47c3-ba32-cc747ab32f9a'
)
AND event_time BETWEEN TIMESTAMP '2023-11-01 20:00' AND TIMESTAMP '2023-11-02 08:00'
GROUP BY device_id
```
Quando você executa essa consulta, o Athena visualiza os três valores para a chave de partição `device_id` e os usa para calcular os locais das partições. O Athena usa os valores com a propriedade `storage.location.template` para gerar os seguintes locais:
+ `s3://amzn-s3-demo-bucket/prefix/4a770164-0392-4a41-8565-40ed8cec737e`
+ `s3://amzn-s3-demo-bucket/prefix/f71d12cf-f01f-4877-875d-128c23cbde17`
+ `s3://amzn-s3-demo-bucket/prefix/763421d8-b005-47c3-ba32-cc747ab32f9a`
Se você omitir a propriedade `storage.location.template` da configuração da projeção de partição, o Athena usará o particionamento no estilo Hive para projetar os locais de partições com base no valor em `LOCATION` (por exemplo, `s3://amzn-s3-demo-bucket/prefix/device_id=4a770164-0392-4a41-8565-40ed8cec737e`).
# Exemplo do Amazon Data Firehose
Quando você usa o Firehose para entregar dados ao Amazon S3, a configuração padrão grava objetos com chaves semelhantes ao seguinte exemplo:
```
s3://amzn-s3-demo-bucket/prefix/yyyy/MM/dd/HH/file.extension
```
Para criar uma tabela do Athena que encontre as partições automaticamente no momento da consulta, em vez de precisar adicioná-las ao AWS Glue Data Catalog à medida que novos dados chegam, você pode usar a projeção de partições.
O exemplo de `CREATE TABLE` a seguir usa a configuração padrão do Firehose.
```
CREATE EXTERNAL TABLE my_ingested_data (
...
)
...
PARTITIONED BY (
datehour STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.datehour.type" = "date",
"projection.datehour.format" = "yyyy/MM/dd/HH",
"projection.datehour.range" = "2021/01/01/00,NOW",
"projection.datehour.interval" = "1",
"projection.datehour.interval.unit" = "HOURS",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${datehour}/"
)
```
A cláusula `TBLPROPERTIES` na instrução `CREATE TABLE` diz ao Athena o seguinte:
+ Usar projeção de partições ao consultar a tabela
+ A chave de partição `datehour` é do tipo `date` (que inclui um horário opcional)
+ Como as datas são formatadas
+ O intervalo dos períodos de datas. Observe que os valores devem ser separados por uma vírgula, não por um hífen.
+ Onde encontrar os dados no Amazon S3.
Quando você consulta a tabela, o Athena calcula os valores para `datehour` e usa o modelo de local de armazenamento para gerar uma lista de locais de partição.
**Topics**
+ [
# Como usar o tipo `date`.
](partition-projection-kinesis-firehose-example-using-the-date-type.md)
+ [
# Como escolher chaves de partição
](partition-projection-kinesis-firehose-example-choosing-partition-keys.md)
+ [
# Como usar prefixos personalizados e particionamento dinâmico
](partition-projection-kinesis-firehose-example-using-custom-prefixes-and-dynamic-partitioning.md)
# Como usar o tipo `date`.
Quando você usa o tipo `date` para a chave de partição projetada, deve especificar um intervalo. Como não há dados para datas antes da criação do fluxo de entrega do Firehose, você pode usar a data de criação como o início. E como você não tem dados para datas no futuro, pode usar o token especial `NOW` como fim.
No exemplo `CREATE TABLE`, a data de início é especificada como 1º de janeiro de 2021 à meia-noite UTC.
**nota**
Configure um intervalo que corresponda o mais exatamente possível aos seus dados para que o Athena procure apenas partições existentes.
Quando uma consulta é executada na tabela de amostra, o Athena usa as condições na chave de partição `datehour` em combinação com o intervalo para gerar valores. Considere a seguinte consulta:
```
SELECT *
FROM my_ingested_data
WHERE datehour >= '2020/12/15/00'
AND datehour < '2021/02/03/15'
```
A primeira condição na consulta `SELECT` usa uma data antes do início do intervalo de datas especificado pela instrução `CREATE TABLE`. Como a configuração de projeção de partições não especifica nenhuma partição para datas antes de 1º de janeiro de 2021, o Athena procura dados somente nos locais a seguir e ignora as datas anteriores na consulta.
```
s3://amzn-s3-demo-bucket/prefix/2021/01/01/00/
s3://amzn-s3-demo-bucket/prefix/2021/01/01/01/
s3://amzn-s3-demo-bucket/prefix/2021/01/01/02/
...
s3://amzn-s3-demo-bucket/prefix/2021/02/03/12/
s3://amzn-s3-demo-bucket/prefix/2021/02/03/13/
s3://amzn-s3-demo-bucket/prefix/2021/02/03/14/
```
Da mesma forma, se a consulta fosse executada em uma data e hora antes de 3 de fevereiro de 2021 às 15:00, a última partição refletiria a data e a hora atuais, não a data e a hora na condição da consulta.
Se você quiser consultar os dados mais recentes, pode aproveitar o fato de que Athena não gera datas futuras e especificar apenas uma `datehour` de início, como no exemplo a seguir.
```
SELECT *
FROM my_ingested_data
WHERE datehour >= '2021/11/09/00'
```
# Como escolher chaves de partição
Você pode especificar como a projeção de partições mapeia os locais de partição para chaves de partição. No exemplo da seção anterior para `CREATE TABLE`, a data e o horário foram combinados em uma chave de partição chamada “datehour”, mas outros esquemas são possíveis. Por exemplo, você também pode configurar uma tabela com chaves de partição separadas por ano, mês, dia e hora.
No entanto, dividir datas em ano, mês e dia significa que o tipo de projeção de partição `date` não pode ser usado. Uma alternativa é separar a data do horário para ainda aproveitar o tipo de projeção da partição `date`, mas facilitar a leitura das consultas que especificam intervalos de horas.
Com isso em mente, o exemplo `CREATE TABLE` a seguir separa a data da hora. Como `date` é uma palavra reservada em SQL, o exemplo usa `day` como nome da chave de partição que representa a data.
```
CREATE EXTERNAL TABLE my_ingested_data2 (
...
)
...
PARTITIONED BY (
day STRING,
hour INT
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.format" = "yyyy/MM/dd",
"projection.day.range" = "2021/01/01,NOW",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"projection.hour.type" = "integer",
"projection.hour.range" = "0,23",
"projection.hour.digits" = "2",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${day}/${hour}/"
)
```
No exemplo de instrução `CREATE TABLE`, a hora é uma chave de partição separada, configurada como um inteiro. A configuração para a chave de partição de hora especifica o intervalo de 0 a 23 e que a hora deverá ser formatada com dois dígitos quando o Athena gerar os locais de partições.
Uma consulta para a tabela `my_ingested_data2` poderia ser semelhante a esta:
```
SELECT *
FROM my_ingested_data2
WHERE day = '2021/11/09'
AND hour > 3
```
## Noções básicas de chave de partição e tipos de dados de projeção de partições
Observe que a chave `datehour` no primeiro exemplo de `CREATE TABLE` é configurada como `date` na configuração de projeção de partições, mas o tipo de chave de partição é `string`. O mesmo vale para `day` no segundo exemplo. Os tipos na configuração de projeção de partições apenas dizem ao Athena como formatar os valores quando ele gera os locais de partição. Os tipos especificados não alteram o tipo da chave de partição. Em consultas, `datehour` e `day` são do tipo `string`.
Quando uma consulta inclui uma condição como `day = '2021/11/09'`, o Athena analisa a sequência do lado direito da expressão usando o formato de data especificado na configuração de projeção de partições. Depois que o Athena verifica se a data está dentro do intervalo configurado, ele usa o formato de data novamente para inserir a data como uma sequência no modelo de local de armazenamento.
Da mesma forma, para uma condição de consulta como `day > '2021/11/09'`, o Athena analisa o lado direito e gera uma lista de todas as datas correspondentes dentro do intervalo configurado. Em seguida, ele usa o formato de data para inserir cada data no modelo de local de armazenamento para criar a lista de locais de partição.
Escrever a mesma condição que `day > '2021-11-09'` ou `day > DATE '2021-11-09'` não funciona. No primeiro caso, o formato de data não corresponde (observe os hifens em vez de barras) e, no segundo caso, os tipos de dados não correspondem.
# Como usar prefixos personalizados e particionamento dinâmico
É possível configurar o Firehose com [prefixos personalizados](https://docs.aws.amazon.com/firehose/latest/dev/s3-prefixes.html) e [particionamento dinâmico](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html). Usando esses recursos, você pode configurar as chaves do Amazon S3 e configurar esquemas de particionamento que suportem melhor seu caso de uso. Você também pode usar a projeção de partições com esses esquemas de particionamento e configurá-los de acordo.
Por exemplo, você pode usar o recurso de prefixo personalizado para obter chaves do Amazon S3 com datas em formato ISO em vez do esquema padrão de `yyyy/MM/dd/HH`.
Você também pode combinar prefixos personalizados com particionamento dinâmico para extrair uma propriedade como `customer_id` das mensagens do Firehose, como no exemplo a seguir.
```
prefix/!{timestamp:yyyy}-!{timestamp:MM}-!{timestamp:dd}/!{partitionKeyFromQuery:customer_id}/
```
Com esse prefixo do Amazon S3, o fluxo de entrega do Firehose gravaria objetos em chaves como `s3://amzn-s3-demo-bucket/prefix/2021-11-01/customer-1234/file.extension`. Para uma propriedade como `customer_id`, na qual os valores podem não ser conhecidos com antecedência, você pode usar o tipo de projeção de partições `injected` e usar uma instrução `CREATE TABLE` como a seguinte:
```
CREATE EXTERNAL TABLE my_ingested_data3 (
...
)
...
PARTITIONED BY (
day STRING,
customer_id STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.format" = "yyyy-MM-dd",
"projection.day.range" = "2021-01-01,NOW",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"projection.customer_id.type" = "injected",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${day}/${customer_id}/"
)
```
Quando você consulta uma tabela que tem uma chave de partição do tipo `injected`, sua consulta deve incluir um valor para essa chave de partição. Uma consulta para a tabela `my_ingested_data3` poderia ser semelhante a esta:
```
SELECT *
FROM my_ingested_data3
WHERE day BETWEEN '2021-11-01' AND '2021-11-30'
AND customer_id = 'customer-1234'
```
## Usar o tipo DATE para a chave de partição do dia
Como os valores para chave de partição `day` são em formato ISO, você também pode usar o tipo `DATE`, em vez de `STRING`, para a chave de partição de dia, como no exemplo a seguir:
```
PARTITIONED BY (day DATE, customer_id STRING)
```
Quando você consulta, essa estratégia permite que você use funções de data na chave de partição sem análise ou conversão, como no exemplo a seguir:
```
SELECT *
FROM my_ingested_data3
WHERE day > CURRENT_DATE - INTERVAL '7' DAY
AND customer_id = 'customer-1234'
```
**nota**
A especificação de uma chave de partição do tipo `DATE` pressupõe que você usou o atributo [custom prefix](https://docs.aws.amazon.com/firehose/latest/dev/s3-prefixes.html) para criar chaves do Amazon S3 que tenham datas no formato ISO. Caso esteja usando o formato padrão de `yyyy/MM/dd/HH` do Firehose, você deverá especificar a chave de partição com o tipo `string`, mesmo que a propriedade da tabela correspondente seja do tipo `date`, como no seguinte exemplo:
```
PARTITIONED BY (
`mydate` string)
TBLPROPERTIES (
'projection.enabled'='true',
...
'projection.mydate.type'='date',
'storage.location.template'='s3://amzn-s3-demo-bucket/prefix/${mydate}')
```
# Prevenir o controle de utilização do Amazon S3
O controle de utilização é o processo de limitar sua taxa de uso de um serviço, uma aplicação ou um sistema. Na AWS, você pode usar o controle de utilização para evitar o uso excessivo do serviço Amazon S3 e aumentar a disponibilidade e a capacidade de resposta do Amazon S3 para todos os usuários. Porém, como o controle de utilização limita a taxa de transferências de dados de entrada e saída do Amazon S3, é importante tentar evitar que suas interações sejam limitadas.
Conforme apontado no capítulo de [ajuste de performance](performance-tuning.md), as otimizações podem depender de suas decisões de nível de serviço, de como você estrutura suas tabelas e dados e de como você escreve suas consultas.
**Topics**
+ [
# Reduzir o controle de utilização no nível de serviço
](performance-tuning-s3-throttling-reduce-throttling-at-the-service-level.md)
+ [
# Otimizar suas tabelas
](performance-tuning-s3-throttling-optimizing-your-tables.md)
+ [
# Otimizar suas consultas
](performance-tuning-s3-throttling-optimizing-queries.md)
# Reduzir o controle de utilização no nível de serviço
Para evitar o controle de utilização do Amazon S3 no nível do serviço, é possível monitorar o uso e ajustar as [cotas de serviço](https://docs.aws.amazon.com/general/latest/gr/s3.html#limits_s3) ou usar certas técnicas, como particionamento. Estas são algumas das condições que podem levar ao controle de utilização:
+ **Exceder os limites de solicitação de API da conta**: o Amazon S3 tem limites de solicitação de API padrão baseados no tipo e no uso da conta. Se você exceder o número máximo de solicitações por segundo para um único prefixo, as solicitações poderão ser limitadas para evitar a sobrecarga do serviço Amazon S3.
+ **Particionamento de dados insuficiente**: se você não particionar os dados corretamente e transferir uma grande quantidade de dados, o Amazon S3 poderá limitar as solicitações. Para obter mais informações sobre particionamento, consulte a seção [Usar particionamento](performance-tuning-s3-throttling-optimizing-your-tables.md#performance-tuning-s3-throttling-use-partitioning) deste documento.
+ **Grande quantidade de objetos pequenos**: se possível, evite uma grande quantidade de arquivos pequenos. O Amazon S3 tem um limite de [5500 solicitações GET](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) por segundo por prefixo particionado, e suas consultas do Athena compartilham esse mesmo limite. Se você verificar milhões de objetos pequenos em uma única consulta, provavelmente o Amazon S3 limitará a consulta.
Para evitar verificação em excesso, você pode usar o recurso ETL do AWS Glue para compactar periodicamente os arquivos ou particionar a tabela e adicionar filtros de chave de partição. Para obter mais informações, consulte os recursos a seguir.
+ [Como posso configurar um trabalho de ETL do AWS Glue para gerar arquivos maiores?](https://aws.amazon.com/premiumsupport/knowledge-center/glue-job-output-large-files/) (*AWS Central de conhecimento da*)
+ [Ler arquivos de entrada em grupos maiores](https://docs.aws.amazon.com/glue/latest/dg/grouping-input-files.html) (*Guia do desenvolvedor do AWS Glue*)
# Otimizar suas tabelas
Caso você encontre problemas de controle de utilização, é importante estruturar os dados. Embora o Amazon S3 consiga lidar com grandes quantidades de dados, às vezes o controle de utilização ocorre devido à forma como os dados são estruturados.
As seções a seguir oferecem algumas sugestões sobre como estruturar dados no Amazon S3 para evitar problemas de controle de utilização.
## Usar particionamento
É possível usar o particionamento para reduzir o controle de utilização limitando a quantidade de dados que precisam ser acessados a qualquer momento. Ao particionar dados em colunas específicas, você pode distribuir as solicitações de maneira uniforme entre vários objetos e reduzir o número de solicitações para um único objeto. Reduzir a quantidade de dados que devem ser verificados melhora a performance da consulta e reduz os custos.
Ao criar uma tabela, você pode definir partições que atuam como colunas virtuais. Para criar uma tabela com partições em uma instrução `CREATE TABLE`, use a cláusula `PARTITIONED BY (column_name data_type)` para definir as chaves para particionar dados.
Para restringir as partições verificadas por uma consulta, é possível especificá-las como predicados em uma cláusula `WHERE` da consulta. Portanto, colunas usadas como filtros com frequência são boas candidatas para particionamento. Uma prática comum é particionar os dados com base na hora, o que pode acarretar um esquema de particionamento em vários níveis.
O particionamento também tem um custo. Quando você aumenta o número de partições na tabela, o tempo necessário para recuperar e processar os metadados da partição também aumenta. Assim, o particionamento excessivo pode remover os benefícios obtidos ao particionar de forma mais criteriosa. Se os dados estiverem muito distorcidos para um valor de partição e a maioria das consultas usar esse valor, você poderá incorrer em aumento de sobrecarga.
Para obter mais informações sobre particionamento no Athena, consulte [O que é particionamento?](ctas-partitioning-and-bucketing-what-is-partitioning.md).
## Classificar dados em bucket
Outra forma de particionar dados é classificá-los em buckets dentro de uma única partição. Com o bucketing, você especifica uma ou mais colunas que contêm linhas que deseja agrupar. Em seguida, você coloca essas linhas em vários buckets. Dessa forma, você consulta somente o bucket que deve ser lido, reduzindo o número de linhas de dados que devem ser verificados.
Ao selecionar uma coluna que será usada para bucketing, selecione a coluna que tenha alta cardinalidade (ou seja, que tenha muitos valores distintos), esteja uniformemente distribuída e seja usada com frequência para filtrar os dados. Um exemplo de uma boa coluna a ser usada para bucketing é uma chave primária, como uma coluna de ID.
Para obter mais informações sobre bucketing no Athena, consulte [O que é bucketing?](ctas-partitioning-and-bucketing-what-is-bucketing.md)
## Usar índices de partição do AWS Glue
Você pode usar índices de partição do AWS Glue para organizar dados em uma tabela com base nos valores de uma ou mais partições. Os índices de partição do AWS Glue podem reduzir o número de transferências de dados, a quantidade de processamento de dados e o tempo de processamento das consultas.
Um índice de partição do AWS Glue é um arquivo de metadados que contém informações sobre as partições da tabela, inclusive as chaves da partição e seus valores. O índice da partição é armazenado em um bucket do Amazon S3 e atualizado automaticamente pelo AWS Glue à medida que novas partições são adicionadas à tabela.
Quando há um índice de partição do AWS Glue presente, as consultas tentam buscar um subconjunto das partições em vez de carregar todas as partições na tabela. As consultas são executadas somente no subconjunto de dados relevante para a consulta.
Ao criar uma tabela no AWS Glue, é possível criar um índice de partição em qualquer combinação de chaves de partição definidas na tabela. Depois de criar um ou mais índices de partição em uma tabela, é necessário adicionar uma propriedade à tabela que habilite a filtragem de partições. Em seguida, você pode consultar a tabela no Athena.
Para obter informações sobre como criar índices de partição no AWS Glue, consulte [Trabalhar com índices de partição no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) no *Guia do desenvolvedor do AWS Glue*. Para obter informações sobre como adicionar uma propriedade de tabela para habilitar a filtragem de partições, consulte [Otimizar consultas com indexação e filtragem de partições do AWS Glue](glue-best-practices-partition-index.md).
## Usar compactação de dados e divisão de arquivos
A compactação de dados pode acelerar consideravelmente as consultas se os arquivos estiverem no tamanho ideal ou se puderem ser divididos em grupos lógicos. Geralmente, taxas de compactação mais altas necessitam de mais ciclos de CPU para compactar e descompactar os dados. Para o Athena, recomendamos usar o Apache Parquet ou o Apache ORC, que compactam dados por padrão. Para obter mais informações sobre compactação de dados no Athena, consulte [Usar compactação no Athena](compression-formats.md).
A divisão de arquivos aumenta o paralelismo ao permitir que o Athena distribua a tarefa de ler um único arquivo entre vários leitores. Se um único arquivo não foi divisível, somente um único leitor poderá ler o arquivo enquanto outros leitores estiverem ociosos. O Apache Parquet e o Apache ORC também são compatíveis com arquivos divisíveis.
## Use armazenamentos de dados em colunas otimizados
A performance da consulta do Athena melhorará consideravelmente se você converter os dados para um formato em colunas. Ao gerar arquivos em colunas, uma técnica de otimização a ser considerada é ordenar os dados com base na chave de partição.
O Apache Parquet e o Apache ORC são armazenamentos de dados em colunas de código aberto bastante usados. Para obter informações sobre como converter a fonte de dados existente do Amazon S3 para um desses formatos, consulte [Converter em formatos colunares](columnar-storage.md#convert-to-columnar).
### Usar um tamanho de bloco do Parquet ou tamanho de faixa ORC maior
O Parquet e o ORC têm parâmetros de armazenamento de dados que podem ser ajustados para otimização. No Parquet, é possível otimizar o tamanho do bloco. No ORC, é possível otimizar o tamanho da faixa. Quanto maior o bloco ou a faixa, mais linhas você poderá armazenar em cada um deles. Por padrão, o tamanho do bloco Parquet é 128 MB, e o tamanho da faixa ORC é 64 MB.
Se uma faixa ORC for menor que 8 MB (o valor padrão de `hive.orc.max_buffer_size`), o Athena lerá toda a faixa ORC. É a compensação que o Athena faz entre a seletividade da coluna e as operações de entrada e saída por segundo para faixas menores.
Se houver tabelas com um número muito grande de colunas, um tamanho pequeno de bloco ou de faixa pode fazer com que sejam verificados mais dados do que o necessário. Nesses casos, um tamanho maior de bloco pode ser mais eficiente.
### Usar ORC para tipos complexos
Atualmente, ao consultar colunas armazenadas em Parquet que tenham tipos de dados complexos (por exemplo, `array`, `map` ou `struct`), o Athena lê a linha de dados inteira em vez de somente as colunas especificadas seletivamente. Este é um problema conhecido do Athena. Como solução alternativa, considere usar o ORC.
### Escolher um algoritmo de compactação
Outro parâmetro que pode ser configurado é o algoritmo de compactação nos blocos de dados. Para obter informações sobre os algoritmos de compactação compatíveis com Parquet e ORC no Athena, consulte [Suporte a compactação no Athena](https://docs.aws.amazon.com/athena/latest/ug/compression-formats.html).
Para obter mais informações sobre a otimização de formatos de armazenamento em colunas no Athena, consulte a seção “Otimizar a geração de armazenamento de dados em colunas” na publicação do AWS Big Data Blog [As dez melhores dicas de ajuste de performance para o Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
## Usar tabelas Iceberg
Apache Iceberg é um formato de tabela aberta para conjuntos de dados analíticos muito grandes, criado para otimizar o uso do Amazon S3. Você pode usar as tabelas Iceberg para ajudar a reduzir o controle de utilização no Amazon S3.
As tabelas Iceberg oferecem as seguintes vantagens:
+ É possível dividir as tabelas Iceberg em partições de uma ou mais colunas. Isso otimiza o acesso aos dados e reduz a quantidade de dados que deverão ser verificados por meio de consultas.
+ Como o modo de armazenamento de objetos do Iceberg otimiza as tabelas Iceberg para funcionar com o Amazon S3, ele pode processar grandes volumes de dados e workloads de consultas pesadas.
+ As tabelas Iceberg no modo de armazenamento de objetos são escaláveis, tolerantes a falhas e duráveis, o que pode ajudar a reduzir o controle de utilização.
+ Com o suporte à transação ACID, vários usuários podem adicionar e excluir objetos do Amazon S3 de forma atômica.
Para obter mais informações sobre o Apache Iceberg, consulte [Apache Iceberg](https://iceberg.apache.org/). Para obter mais informações sobre como usar tabelas Apache Iceberg no Athena, consulte [Usar tabelas Iceberg](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg.html).
# Otimizar suas consultas
Use as sugestões desta seção para otimizar as consultas SQL no Athena.
## Usar LIMIT com a cláusula ORDER BY
A cláusula `ORDER BY` retorna dados em uma ordem classificada. Isso exige que o Athena envie todas as linhas de dados para um único nó de processamento e classifique as linhas. Esse tipo de consulta pode ser executado por muito tempo ou pode até falhar.
Para aumentar a eficiência das consultas, observe os valores *N* superiores ou inferiores e use também uma cláusula `LIMIT`. Isso reduz significativamente o custo de classificação, inserindo tanto a classificação como a limitação em nós de processamento individuais, e não em um único operador.
## Otimizar cláusulas JOIN
Quando você une duas tabelas, o Athena distribui a tabela à direita para os nós de processamento e transmite a tabela à esquerda para realizar a junção.
Por isso, especifique a tabela maior no lado esquerdo da junção e a tabela menor no lado direito da junção. Assim, o Athena usa menos memória e executa a consulta com menor latência.
Observe também os seguintes pontos:
+ Ao usar vários comandos `JOIN`, especifique as tabelas da maior para a menor.
+ Evite junções cruzadas, a menos que sejam exigidas pela consulta.
## Otimizar cláusulas GROUP BY
O operador `GROUP BY` distribui as linhas com base nas colunas `GROUP BY` para os nós de processamento. Essas colunas são referenciadas na memória, e os valores são comparados à medida que as linhas são ingeridas. Os valores são agregados quando a coluna `GROUP BY` coincide. Considerando a forma como o processo funciona, é aconselhável ordenar as colunas da maior cardinalidade para a menor.
## Usar números em vez de strings
Como os números exigem menos memória e são mais rápidos de processar em comparação com as strings, use números em vez de strings quando possível.
## Limitar o número de colunas
Para reduzir a quantidade total de memória necessária para armazenar os dados, limite o número de colunas especificado na instrução `SELECT`.
## Usar expressões regulares em vez de LIKE
Consultas que incluem cláusulas como `LIKE '%string%'` em strings grandes podem fazer uso muito intensivo de computação. Ao filtrar por vários valores em uma coluna de string, use a função [regexp\$1like()](https://trino.io/docs/current/functions/regexp.html#regexp_like) e uma expressão regular. Isso é útil especialmente ao comparar uma longa lista de valores.
## Usar a cláusula LIMIT
Em vez de selecionar todas as colunas ao executar uma consulta, use a cláusula `LIMIT` para retornar somente as colunas necessárias. Essa ação reduz o tamanho do conjunto de dados que é processado pelo pipeline de execução da consulta. As cláusulas `LIMIT` são mais úteis ao consultar tabelas que têm um grande número de colunas baseadas em strings. As cláusulas `LIMIT` também são úteis ao executar várias junções ou agregações em qualquer consulta.
# Recursos adicionais
Para obter mais informações sobre ajuste de performance no Athena, acesse estes recursos:
+ Publicação no Blog de Big Data da AWS: [As 10 melhores dicas de ajuste de performance do Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
+ Publicação no Blog de Big Data da AWS: [Executa consultas 3 vezes mais rápido e com até 70% de economia de custos no mecanismo mais recente do Amazon Athena](https://aws.amazon.com/blogs/big-data/run-queries-3x-faster-with-up-to-70-cost-savings-on-the-latest-amazon-athena-engine/) no *Blog de Big Data da AWS*.
+ Publicação no Blog de Big Data da AWS: [Aprimorar consultas federadas com a redução de predicados no Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/).
+ Guia do usuário do Amazon Simple Storage Service: [Práticas recomendadas de padrões de design: otimização da performance do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html).
+ Outras [publicações do Athena no Blog de Big Data da AWS](https://aws.amazon.com/blogs/big-data/tag/amazon-athena/)
+ Faça uma pergunta no [AWS re:Post](https://repost.aws/tags/TA78iVOM7gR62_QqDe2-CmiA/amazon-athena) usando a tag **Amazon Athena**
+ Consulte os [tópicos do Athena na Central de Conhecimento da AWS](https://aws.amazon.com/premiumsupport/knowledge-center/#Amazon_Athena)
+ Entre em contato com AWS Support (no Console de gerenciamento da AWS, clique em **Support** (Suporte), **Support Center** (Central de Suporte))
# Usar compactação no Athena
O Athena suporta uma variedade de formatos de compactação para leitura e gravação de dados, incluindo a leitura de uma tabela que usa vários formatos de compactação. Por exemplo, o Athena pode ler com sucesso os dados de uma tabela que usa o formato de arquivo Parquet quando alguns arquivos Parquet são compactados com o Snappy e outros arquivos Parquet são compactados com o GZIP. O mesmo princípio se aplica aos formatos de armazenamento ORC, arquivo de texto e JSON.
## Formatos de compactação com suporte
O Athena aceita os seguintes formatos de compactação:
+ **BZIP2**: formato que usa o algoritmo de Burrows-Wheeler.
+ **DEFLATE**: algoritmo de compactação de dados baseado em codificação [LZSS](https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Storer%E2%80%93Szymanski) e [Huffman](https://en.wikipedia.org/wiki/Huffman_coding). [Deflate](https://en.wikipedia.org/wiki/Deflate) só é relevante para o formato de arquivo Avro.
+ **GZIP**: algoritmo de compactação baseado em Deflate. Para tabelas do Hive no mecanismo do Athena versões 2 e 3, e tabelas do Iceberg no mecanismo do Athena versão 2, o GZIP é o formato de compactação de gravação padrão para arquivos nos formatos de armazenamento de arquivos Parquet e de texto. Arquivos no formato `tar.gz` não são suportados.
+ **LZ4**: este membro da família Lempel-Ziv 77 (LZ7) também se concentra na velocidade de compactação e descompactação, não na compactação máxima dos dados. O LZ4 tem os seguintes formatos de enquadramento:
+ **LZ4 Raw/Unframed**: uma implementação sem quadros padrão do formato de compactação de blocos LZ4. Para obter mais informações, consulte [LZ4 Block Format Description](https://github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md) (Descrição do formato de bloco LZ4) no GitHub.
+ **LZ4 framed**: a implementação de enquadramento usual do LZ4. Para obter mais informações, consulte [LZ4 Frame Format Description](https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md) (Descrição do formato de quadro LZ4) no GitHub.
+ **LZ4 Hadoop-compatible**: a implementação do Apache Hadoop do LZ4. Esta implementação envolve a compactação LZ4 com a classe [BlockCompressorStream.java](https://github.com/apache/hadoop/blob/f67237cbe7bc48a1b9088e990800b37529f1db2a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/compress/BlockCompressorStream.java).
+ **LZO**: formato que usa o algoritmo Lempel-Ziv-Oberhumer, que se concentra na alta velocidade de compactação e descompactação, não na compactação máxima dos dados. O LZO tem duas implementações:
+ **Standard LZO**: para obter mais informações, consulte o [resumo](http://www.oberhumer.com/opensource/lzo/#abstract) do LZO no site da Oberhumer.
+ **LZO Hadoop-compatible**: esta implementação envolve o algoritmo LZO com a classe [BlockCompressorStream.java](https://github.com/apache/hadoop/blob/f67237cbe7bc48a1b9088e990800b37529f1db2a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/compress/BlockCompressorStream.java).
+ **SNAPPY**: algoritmo de compactação que faz parte da família Lempel-Ziv 77 (LZ7). O Snappy se concentra na alta velocidade de compactação e descompactação, não na compactação máxima do dados.
+ **ZLIB**: com base no Deflate, ZLIB é o formato de compactação de gravação padrão para arquivos no formato de armazenamento de dados ORC. Para obter mais informações, consulte a página [zib](https://github.com/madler/zlib) no GitHub.
+ **ZSTD**: o [algoritmo de compactação de dados Zstandard](http://facebook.github.io/zstd/) é um algoritmo de compactação rápida que fornece altas taxas de compactação. A biblioteca Zstandard (ZSTD) é fornecida como software de código aberto usando uma licença BSD. O ZSTD é a compactação padrão para tabelas do Iceberg. O Athena usa o nível 3 de compactação ZSTD por padrão quando grava dados compactados como ZSTD. Para obter mais informações sobre o uso de níveis de compactação ZSTD no Athena, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md).
**nota**
O Athena não é compatível com gravação de arquivos compactados Parquet nos formatos LZ4 ou LZO. Ainda há compatibilidade com leituras para esses formatos de compactação.
## Especificar formatos de compactação
Ao escrever instruções CREATE TABLE ou CTAS, você pode especificar propriedades de compactação que especifiquem o tipo de compactação a ser usado quando o Athena gravar nessas tabelas.
+ Para CTAS, consulte [Propriedades da tabela CTAS](create-table-as.md#ctas-table-properties). Para obter exemplos, consulte [Exemplos de consultas CTAS](ctas-examples.md).
+ Para CREATE TABLE, consulte [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md) para obter uma lista de propriedades da tabela de compactação.
## Especificar nenhuma compactação
As instruções CREATE TABLE são compatíveis com a gravação de arquivos descompactados. Para gravar arquivos descompactados, use a seguinte sintaxe:
+ CREATE TABLE (arquivo de texto ou JSON): Em `TBLPROPERTIES`, especifique `write.compression = NONE`.
+ CREATE TABLE (Parquet): em `TBLPROPERTIES`, especifique `parquet.compression = UNCOMPRESSED`.
+ CREATE TABLE (ORC): em `TBLPROPERTIES`, especifique `orc.compress = NONE`.
## Observações e recursos
+ Atualmente, extensões de arquivos em letras maiúsculas, como `.GZ` ou `.BZIP2`, não são reconhecidas pelo Athena. Evite usar conjuntos de dados com extensões de arquivos em letras maiúsculas ou altere essas extensões para letras minúsculas.
+ Para dados em CSV, TSV e JSON, o Athena determina o tipo de compactação com base na extensão do arquivo. Se nenhuma extensão de arquivo estiver presente, o Athena tratará os dados como texto simples sem compactação. Se os dados estiverem compactados, certifique-se de que o nome do arquivo inclua a extensão de compactação, como `gz`.
+ O formato de arquivo ZIP não é compatível.
+ Para consultar os logs do Amazon Data Firehose usando o Athena, os formatos compatíveis incluem a compactação GZIP ou os arquivos ORC com compactação SNAPPY.
+ Para obter mais informações sobre como usar a compactação, consulte a seção 3 (“Compress and split files” [Compactar e dividir arquivos]) da publicação do blog da AWS sobre big data: [Top 10 performance tuning tips for Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) (As dez melhores dicas de ajuste de performance do Amazon Athena).
**Topics**
+ [
## Especificar formatos de compactação
](#compression-support-specifying-compression-formats)
+ [
## Especificar nenhuma compactação
](#compression-support-specifying-no-compression)
+ [
## Observações e recursos
](#compression-support-notes-and-resources)
+ [Compactação de tabelas do Hive](compression-support-hive.md)
+ [Compactação de tabelas do Iceberg](compression-support-iceberg.md)
+ [Níveis de compactação ZSTD](compression-support-zstd-levels.md)
# Usar a compactação de tabelas do Hive
As opções de compactação de tabelas do Hive no Athena variam de acordo com a versão do mecanismo e o formato do arquivo.
## Suporte à compactação do Hive na versão 3 do mecanismo do Athena
A tabela a seguir resume o suporte a formatos de compactação na versão 3 do mecanismo no Athena para formatos de arquivo de armazenamento no Apache Hive. O formato de arquivo de texto inclui TSV, CSV, JSON e SerDes personalizado para texto. “Sim” ou “Não” em uma célula se aplicam igualmente às operações de leitura e gravação, exceto quando indicado. Para as finalidades desta tabela, CREATE TABLE, CTAS e INSERT INTO serão consideradas operações de gravação. Para obter mais informações sobre o uso de níveis de compressão ZSTD no Athena, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md).
****
| | Avro | Ion | ORC | Parquet | Arquivo de texto |
| --- | --- | --- | --- | --- | --- |
| BZIP2 | Sim | Sim | Não | Não | Sim |
| DEFLATE | Sim | Não | Não | Não | Não |
| GZIP | Não | Sim | Não | Sim | Sim |
| LZ4 | Não | Sim | Sim | Gravação: não Leitura: sim | Sim |
| LZO | Não | Gravação: não Leitura: sim | Não | Gravação: não Leitura: sim | Gravação: não Leitura: sim |
| SNAPPY | Sim | Sim | Sim | Sim | Sim |
| ZLIB | Não | Não | Sim | Não | Não |
| ZSTD | Sim | Sim | Sim | Sim | Sim |
| NONE | Sim | Sim | Sim | Sim | Sim |
# Usar compactação de tabelas do Iceberg
As opções de compactação das tabelas do Iceberg no Athena variam de acordo com a versão do mecanismo e o formato do arquivo.
## Suporte à compactação do Iceberg na versão 3 do mecanismo do Athena
A tabela a seguir resume o suporte a formatos de compactação na versão 3 do mecanismo no Athena para formatos de arquivo de armazenamento no Apache Iceberg. “Sim” ou “Não” em uma célula se aplicam igualmente às operações de leitura e gravação, exceto quando indicado. Para as finalidades desta tabela, CREATE TABLE, CTAS e INSERT INTO serão consideradas operações de gravação. O formato de armazenamento padrão para o Iceberg no mecanismo do Athena versão 3 é Parquet. O formato de compactação padrão para o Iceberg no mecanismo do Athena versão 3 é ZSTD. Para obter mais informações sobre o uso de níveis de compressão ZSTD no Athena, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md).
****
| | Avro | ORC | Parquet (padrão) |
| --- | --- | --- | --- |
| BZIP2 | Não | Não | Não |
| GZIP | Sim | Não | Sim |
| LZ4 | Não | Sim | Não |
| SNAPPY | Sim | Sim | Sim |
| ZLIB | Não | Sim | Não |
| ZSTD | Sim | Sim | Sim (padrão) |
| NONE | Sim (especificar None ou Deflate) | Sim | Sim (especificar None ou Uncompressed) |
# Usar níveis de compactação ZSTD
O [algoritmo de compactação de dados em tempo real Zstandard](http://facebook.github.io/zstd/) é um algoritmo de compactação rápida que fornece altas taxas de compactação. A biblioteca Zstandard (ZSTD) é um software de código aberto e usa uma licença BSD. O Athena oferece suporte a leitura e a gravação de dados nos formatos ORC, Parquet e arquivo de texto compactados como ZSTD.
Você pode usar os níveis de compactação ZSTD para ajustar a taxa e a velocidade de compactação de acordo com suas necessidades. A biblioteca ZSTD é compatível com níveis de compactação de 1 a 22. O Athena usa o nível 3 de compactação ZSTD por padrão.
Os níveis de compactação oferecem compensações granulares entre a velocidade e a quantidade de compactação alcançadas. Níveis de compactação mais baixos oferecem maior velocidade, mas tamanhos de arquivo maiores. Por exemplo, você pode usar o nível 1 se a velocidade for mais importante e o nível 22 se o tamanho for mais importante. O nível 3 é adequado para muitos casos de uso e é o padrão. Use níveis maiores que 19 com cuidado, pois eles exigem mais memória. A biblioteca ZSTD também oferece níveis de compactação negativos que ampliam a faixa de velocidade e taxas de compactação. Para obter mais informações, consulte [Zstandard Compression RFC](https://datatracker.ietf.org/doc/html/rfc8478).
A abundância de níveis de compactação oferece oportunidades substanciais para ajustes finos. No entanto, certifique-se de medir seus dados e considerar as desvantagens ao decidir sobre um nível de compactação. Recomendamos usar o nível padrão de 3 ou um nível na faixa de 6 a 9 para uma compensação razoável entre a velocidade de compactação e o tamanho dos dados compactados. Reserve níveis 20 ou mais para casos em que o tamanho é mais importante e a velocidade de compactação não é uma preocupação.
## Considerações e limitações
Ao usar o nível de compactação ZSTD no Athena, acesse os seguintes pontos.
+ A propriedade `compression_level` da ZSTD tem suporte apenas no mecanismo Athena versão 3.
+ A propriedade `compression_level` da ZSTD é compatível com as instruções `ALTER TABLE`, `CREATE TABLE`, `CREATE TABLE AS` (CTAS) e `UNLOAD`.
+ A propriedade `compression_level` é opcional.
+ A propriedade `compression_level` tem suporte apenas para compactação ZSTD.
+ Os níveis de compactação possíveis são de 1 a 22.
+ O nível de compactação padrão é 3.
Para obter informações sobre suporte à compactação do Apache Hive ZSTD no Athena, consulte [Usar a compactação de tabelas do Hive](compression-support-hive.md). Para obter informações sobre suporte à compactação do Apache Iceberg ZSTD no Athena, consulte [Usar compactação de tabelas do Iceberg](compression-support-iceberg.md).
## Especificar níveis de compactação ZSTD
Para especificar o nível de compactação ZSTD para as instruções `ALTER TABLE`, `CREATE TABLE`, `CREATE TABLE AS` e `UNLOAD`, use a propriedade `compression_level`. Para especificar a compactação ZSTD em si, você deve usar a propriedade de compactação individual que a sintaxe da instrução usa.
### ALTER TABLE SET TBLPROPERTIES
Na cláusula `SET TBLPROPERTIES` da instrução [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md), especifique a compactação ZSTD usando `'write.compression' = ' ZSTD'` ou `'parquet.compression' = 'ZSTD'`. Em seguida, use a propriedade `compression_level` para especificar um valor de 1 a 22 (por exemplo, '`compression_level' = '5'`). Se você não especificar uma propriedade de nível de compactação, o padrão será 3.
#### Exemplo
O exemplo a seguir modifica a tabela `existing_table` para usar o formato de arquivo Parquet com compactação ZSTD nível 4. Observe que na cláusula `TBLPROPERTIES`, o valor do nível de compactação deve ser inserido como uma string em vez de um número inteiro e, portanto, deve ser inserido entre aspas simples ou duplas.
```
ALTER TABLE existing_table
SET TBLPROPERTIES ('parquet.compression' = 'ZSTD', 'compression_level' = '4')
```
### CRIAR TABELA
Na cláusula `TBLPROPERTIES` da instrução [CREATE TABLE](create-table.md), especifique '`write.compression' = 'ZSTD'` ou `'parquet.compression' = 'ZSTD'`, e, em seguida, use `compression_level = compression_level` e especifique um valor de 1 a 22 como string.. Se a propriedade `compression_level` não for especificada, o nível de compressão padrão será 3.
#### Exemplo
O exemplo a seguir cria uma tabela no formato de arquivo Parquet usando compactação ZSTD nível 4.
```
CREATE EXTERNAL TABLE new_table (
`col0` string COMMENT '',
`col1` string COMMENT ''
)
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/'
TBLPROPERTIES ('write.compression' = 'ZSTD', 'compression_level' = '4')
```
### CREATE TABLE AS (CTAS)
Na cláusula `WITH` da instrução [CREATE TABLE AS](create-table-as.md), especifique `write_compression = 'ZSTD'` ou `parquet_compression = 'ZSTD'`, e, em seguida, use `compression_level = compression_level` e especifique um valor de 1 a 22 como um inteiro. Se a propriedade `compression_level` não for especificada, o nível de compressão padrão será 3.
#### Exemplo
O exemplo de CTAS a seguir especifica o Parquet como formato de arquivo usando compactação ZSTD nível 4. Observe que, na cláusula `WITH`, o valor do nível de compactação deve ser especificado como um número inteiro, não como uma string.
```
CREATE TABLE new_table
WITH ( format = 'PARQUET', write_compression = 'ZSTD', compression_level = 4)
AS SELECT * FROM old_table
```
### UNLOAD
Na cláusula `WITH` da instrução [UNLOAD](unload.md), especifique `compression = 'ZSTD'` e, em seguida, use `compression_level = compression_level` e especifique um valor de 1 a 22 como um inteiro. Se a propriedade `compression_level` não for especificada, o nível de compressão padrão será 3.
#### Exemplo
O exemplo a seguir descarrega os resultados da consulta no local especificado usando o formato de arquivo Parquet, a compactação ZSTD e o nível 4 de compactação ZSTD.
```
UNLOAD (SELECT * FROM old_table)
TO 's3://amzn-s3-demo-bucket/'
WITH (format = 'PARQUET', compression = 'ZSTD', compression_level = 4)
```
# Marcar recursos do Athena com tags
Uma tag consiste em uma chave e um valor, ambos definidos por você. Ao marcar um recurso do Athena, você atribui metadados personalizados a ele. Você pode usar etiquetas para categorizar seus recursos da AWS de diferentes formas, como por finalidade, proprietário ou ambiente. No Athena, recursos como grupos de trabalho, catálogos de dados e reservas de capacidade são recursos etiquetáveis. Por exemplo, você pode criar um conjunto de tags para grupos de trabalho na sua conta que ajuda a rastrear os proprietários do grupo de trabalho ou identificar grupos de trabalho por finalidade. Se você também habilitar as tags como tags de alocação de custos no console do Billing and Cost Management, os custos associados à execução de consultas aparecerão em seu Relatório de custos e uso com essa tag de alocação de custos. Recomendamos usar as [práticas recomendadas de marcação com tags](https://docs.aws.amazon.com/whitepapers/latest/tagging-best-practices/tagging-best-practices.html) da AWS para criar um conjunto consistente de tags que atenda às necessidades da sua organização.
Você pode trabalhar com etiquetas usando o console do Athena ou as operações de API.
**Topics**
+ [
## Conceitos Básicos de Tags
](#tag-basics)
+ [
## Restrições de tags
](#tag-restrictions)
+ [
# Trabalhar com tags para grupos de trabalho
](tags-console.md)
+ [
# Usar API e operações de tag da AWS CLI
](tags-operations.md)
+ [
# Usar políticas de controle de acesso do IAM baseadas em tags
](tags-access-control.md)
## Conceitos Básicos de Tags
Uma etiqueta é um rótulo atribuído a um recurso do Athena. Cada tag consiste de uma chave e um valor opcional, que podem ser definidos.
As etiquetas permitem categorizar seus recursos da AWS de maneiras diferentes. Por exemplo, você pode definir um conjunto de tags para os grupos de trabalho da sua conta que ajudem a rastrear o proprietário ou a finalidade de cada grupo de trabalho.
É possível adicionar etiquetas ao criar um grupo de trabalho ou catálogo de dados do Athena ou adicionar, editar ou remover etiquetas dele. Você pode editar uma tag no console. Se você usar as operações da API para editar uma tag, remova a tag antiga e adicione uma nova. Caso exclua um recurso, todas as respectivas tags também serão excluídas.
O Athena não atribui etiquetas automaticamente aos recursos. É possível editar chaves de tags e valores, e é possível remover as tags de um recurso a qualquer momento. É possível definir o valor de uma tag a uma string vazia, mas não pode configurar o valor de um tag como nula. Não adicione chaves de tag duplicadas ao mesmo recurso. Se você fizer isso, o Athena emitirá uma mensagem de erro. Se você usar a ação **TagResource** para marcar um recurso usando uma chave de tag existente, o novo valor da tag substituirá o valor antigo.
No IAM, é possível controlar quais usuários na sua conta da Amazon Web Services têm permissão para criar, editar, remover ou listar etiquetas. Para obter mais informações, consulte [Usar políticas de controle de acesso do IAM baseadas em tags](tags-access-control.md).
Para obter uma lista completa de ações de etiqueta 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/).
Você pode usar tags para faturamento. Para obter mais informações, consulte [Usar etiquetas para faturamento](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) no *Guia do usuário do Gerenciamento de Faturamento e Custos da AWS*.
Para obter mais informações, consulte [Restrições de tags](#tag-restrictions).
## Restrições de tags
As tags têm as seguintes restrições:
+ No Athena, você pode marcar grupos de trabalho, catálogos de dados e reservas de capacidade. Você não pode marcar consultas com tags.
+ O número máximo de tags por recurso é 50. Para permanecer no limite, revise e exclua tags não utilizadas.
+ Em todos os recursos, cada chave de tag deve ser exclusiva e possuir apenas um valor. Não adicione chaves de tag duplicadas ao mesmo tempo ao mesmo recurso. Se você fizer isso, o Athena emitirá uma mensagem de erro. Se você marcar um grupo de trabalho usando uma chave de tag existente em uma ação `TagResource` separada, o novo valor da tag substituirá o valor antigo.
+ O comprimento da chave da tag é de 1-128 caracteres Unicode em UTF-8.
+ O comprimento do valor da tag é de 0-256 caracteres Unicode em UTF-8.
Marcar operações, como adicionar, editar, remover ou listar tags, exigem que você especifique um ARN para o recurso do grupo de trabalho.
+ O Athena permite usar letras, números, espaços representados em UTF-8 e os seguintes caracteres: \$1 - = . \$1 : / @.
+ As chaves e os valores de tags diferenciam maiúsculas de minúsculas.
+ O prefixo `"aws:"` nas chaves de tag é reservado para uso da AWS. Você não pode editar nem excluir chaves de tag com esse prefixo. As tags com esse prefixo não contam contra o limite de tags por recurso.
+ As etiquetas atribuídas estão disponíveis somente para a sua conta da Amazon Web Services.
# Trabalhar com tags para grupos de trabalho
Usando o console do Athena, você pode ver quais etiquetas estão em uso por cada grupo de trabalho na sua conta. Você só pode visualizar as tags por grupo de trabalho. Você também pode usar o console do Athena para aplicar, editar ou remover as etiquetas de um grupo de trabalho por vez.
Você pode pesquisar grupos de trabalho usando as tags criadas.
**Topics**
+ [
## Exibir tags para grupos de trabalho individuais
](#tags-display)
+ [
## Adicionar e excluir tags em um grupo de trabalho individual
](#tags-add-delete)
## Exibir tags para grupos de trabalho individuais
**Para exibir as etiquetas de um grupo de trabalho individual 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 menu de navegação, escolha **Workgroups** (Grupos de trabalho) e escolha o grupo de trabalho desejado.
1. Execute um destes procedimentos:
+ Escolha a guia **Tags**. Se a lista de etiquetas for longa, use a caixa de pesquisa.
+ Escolha **Edit** (Editar) e, em seguida, role para baixo até a seção **Tags** (Etiquetas).
## Adicionar e excluir tags em um grupo de trabalho individual
Você pode gerenciar as tags de um único grupo de trabalho diretamente pela guia **Workgroups (Grupos de trabalho)**.
**nota**
Se você deseja que os usuários adicionem etiquetas ao criarem um grupo de trabalho no console ou especifiquem etiquetas quando usarem a ação **CreateWorkGroup**, conceda a eles permissões do IAM para as ações **TagResource** e **CreateWorkGroup**.
**Para adicionar uma etiqueta ao criar um novo grupo de trabalho**
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No menu de navegação, escolha **Workgroups** (Grupos de trabalho).
1. Escolha **Create workgroup** (Criar grupo de trabalho) e preencha os valores, conforme necessário. Para saber detalhes das etapas, consulte [Criar um grupo de trabalho](creating-workgroups.md).
1. Na seção **Tags** (Etiquetas), adicione uma ou mais etiquetas especificando chaves e valores. Não adicione chaves de tag duplicadas ao mesmo tempo ao mesmo grupo de trabalho. Se você fizer isso, o Athena emitirá uma mensagem de erro. Para obter mais informações, consulte [Restrições de tags](tags.md#tag-restrictions).
1. Ao concluir, escolha **Create workgroup** (Criar grupo de trabalho).
**Para adicionar ou editar uma tag a um grupo de trabalho existente**
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 **Global networks** (Redes globais).
1. Escolha o grupo de trabalho que você deseja modificar.
1. Execute um destes procedimentos:
+ Escolha a guia **Tags** e escolha **Gerenciar tags**.
+ Escolha **Edit** (Editar) e, em seguida, role para baixo até a seção **Tags** (Etiquetas).
1. Especifique uma chave e um valor para cada etiqueta. Para obter mais informações, consulte [Restrições de tags](tags.md#tag-restrictions).
1. Escolha **Salvar**.
**Para excluir uma tag de um grupo de trabalho individual**
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 **Global networks** (Redes globais).
1. Escolha o grupo de trabalho que você deseja modificar.
1. Execute um destes procedimentos:
+ Escolha a guia **Tags** e escolha **Gerenciar tags**.
+ Escolha **Edit** (Editar) e, em seguida, role para baixo até a seção **Tags** (Etiquetas).
1. Na lista de etiquetas, escolha **Remove** (Remover) para a etiqueta que você quer excluir e, em seguida, escolha **Save** (Salvar).
# Usar API e operações de tag da AWS CLI
Use as seguintes operações de tag para adicionar, remover ou listar tags em um recurso.
****
| solicitações de | CLI | Descrição da ação |
| --- | --- | --- |
| TagResource | tag-resource | Adicione ou substitua uma ou mais tags no recurso que tem o ARN especificado. |
| UntagResource | untag-resource | Exclua uma ou mais tags do recurso que tem o ARN especificado. |
| ListTagsForResource | list‑tags‑for‑resource | Liste uma ou mais tags para o recurso que tem o ARN especificado. |
**Adicionar tags ao criar um recurso**
Para adicionar tags ao criar um grupo de trabalho ou catálogo de dados, use o parâmetro `tags` com as operações `CreateWorkGroup` ou `CreateDataCatalog` da API ou com os comandos AWS CLI ou `create-work-group` da `create-data-catalog`.
## Gerenciar tags por meio de ações da API
Os exemplos a seguir mostram como usar ações da API de tags para gerenciar tags em grupos de trabalho e catálogos de dados. Os exemplos estão na linguagem de programação Java.
### Exemplo: TagResource
O exemplo a seguir adiciona duas tags ao grupo de trabalho `workgroupA`:
```
List tags = new ArrayList<>();
tags.add(new Tag().withKey("tagKey1").withValue("tagValue1"));
tags.add(new Tag().withKey("tagKey2").withValue("tagValue2"));
TagResourceRequest request = new TagResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA")
.withTags(tags);
client.tagResource(request);
```
O exemplo a seguir adiciona duas tags ao catálogo de dados `datacatalogA`:
```
List tags = new ArrayList<>();
tags.add(new Tag().withKey("tagKey1").withValue("tagValue1"));
tags.add(new Tag().withKey("tagKey2").withValue("tagValue2"));
TagResourceRequest request = new TagResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA")
.withTags(tags);
client.tagResource(request);
```
**nota**
Não adicione chaves de tag duplicadas ao mesmo recurso. Se você fizer isso, o Athena emitirá uma mensagem de erro. Se você marcar um grupo de trabalho usando uma chave de tag existente em uma ação `TagResource` separada, o novo valor da tag substituirá o valor antigo.
### Exemplo: UntagResource
O exemplo a seguir remove `tagKey2` do grupo de trabalho `workgroupA`:
```
List tagKeys = new ArrayList<>();
tagKeys.add("tagKey2");
UntagResourceRequest request = new UntagResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA")
.withTagKeys(tagKeys);
client.untagResource(request);
```
O exemplo a seguir remove `tagKey2` do catálogo de dados `datacatalogA`:
```
List tagKeys = new ArrayList<>();
tagKeys.add("tagKey2");
UntagResourceRequest request = new UntagResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA")
.withTagKeys(tagKeys);
client.untagResource(request);
```
### Exemplo: ListTagsForResource
O exemplo a seguir lista as tags do grupo de trabalho `workgroupA`:
```
ListTagsForResourceRequest request = new ListTagsForResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA");
ListTagsForResourceResult result = client.listTagsForResource(request);
List resultTags = result.getTags();
```
O exemplo a seguir lista as tags do catálogo de dados `datacatalogA`:
```
ListTagsForResourceRequest request = new ListTagsForResourceRequest()
.withResourceARN("arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA");
ListTagsForResourceResult result = client.listTagsForResource(request);
List resultTags = result.getTags();
```
## Gerenciar tags usando a AWS CLI
Os exemplos a seguir mostram como usar a AWS CLI para criar e gerenciar tags em catálogos de dados.
### Adicionar tags a um recurso: tag-resource
O comando `tag-resource` adiciona uma ou mais tags a um recurso especificado.
**Sintaxe**
`aws athena tag-resource --resource-arn arn:aws:athena:region:account_id:datacatalog/catalog_name --tags Key=string,Value=string Key=string,Value=string`
O parâmetro `--resource-arn` especifica o recurso ao qual as tags são adicionadas. O parâmetro `--tags` especifica uma lista de pares de chave-valor separados por espaço a serem adicionados como tags ao recurso.
**Example**
O exemplo a seguir adiciona tags ao catálogo de dados `mydatacatalog`.
```
aws athena tag-resource --resource-arn arn:aws:athena:us-east-1:111122223333:datacatalog/mydatacatalog --tags Key=Color,Value=Orange Key=Time,Value=Now
```
Para mostrar o resultado, use o comando `list-tags-for-resource`.
Para obter informações sobre como adicionar etiquetas ao usar o comando `create-data-catalog`, consulte [Registrar um catálogo: create-data-catalog](datastores-hive-cli.md#datastores-hive-cli-registering-a-catalog).
### Listar tags de um recurso: list-tags-for-resource
O comando `list-tags-for-resource` lista as tags do recurso especificado.
**Sintaxe**
`aws athena list-tags-for-resource --resource-arn arn:aws:athena:region:account_id:datacatalog/catalog_name`
O parâmetro `--resource-arn` especifica o recurso para o qual as tags são listadas.
O exemplo a seguir lista as tags do catálogo de dados `mydatacatalog`.
```
aws athena list-tags-for-resource --resource-arn arn:aws:athena:us-east-1:111122223333:datacatalog/mydatacatalog
```
O resultado de exemplo a seguir está em formato JSON.
```
{
"Tags": [
{
"Key": "Time",
"Value": "Now"
},
{
"Key": "Color",
"Value": "Orange"
}
]
}
```
### Remover tags de um recurso: untag-resource
O comando `untag-resource` remove as chaves de tag especificadas e seus valores associados do recurso especificado.
**Sintaxe**
`aws athena untag-resource --resource-arn arn:aws:athena:region:account_id:datacatalog/catalog_name --tag-keys key_name [key_name ...]`
O parâmetro `--resource-arn` especifica o recurso do qual as tags são removidas. O parâmetro `--tag-keys` usa uma lista separada por espaços de nomes de chave. Para cada nome de chave especificado, o comando `untag-resource` remove a chave e seu valor.
O exemplo a seguir remove as chaves `Color` e `Time` e seus valores do recurso de catálogo `mydatacatalog`.
```
aws athena untag-resource --resource-arn arn:aws:athena:us-east-1:111122223333:datacatalog/mydatacatalog --tag-keys Color Time
```
# Usar políticas de controle de acesso do IAM baseadas em tags
As etiquetas permitem que você escreva uma política do IAM que inclua o bloco `Condition` para controlar o acesso a um recurso com base em suas etiquetas. Esta seção inclui exemplos de políticas de tags para recursos de grupos de trabalho e catálogos de dados.
## Exemplos de política de etiquetas para grupos de trabalho
### Exemplo: política básica de aplicação de tags
A seguinte política do IAM permite que você execute consultas e interaja com as etiquetas do grupo de trabalho chamado `workgroupA`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:ListEngineVersions",
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:GetDatabase",
"athena:ListTableMetadata",
"athena:GetTableMetadata"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:GetWorkGroup",
"athena:TagResource",
"athena:UntagResource",
"athena:ListTagsForResource",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:BatchGetQueryExecution",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResults",
"athena:GetQueryResultsStream",
"athena:CreateNamedQuery",
"athena:GetNamedQuery",
"athena:BatchGetNamedQuery",
"athena:ListNamedQueries",
"athena:DeleteNamedQuery",
"athena:CreatePreparedStatement",
"athena:GetPreparedStatement",
"athena:ListPreparedStatements",
"athena:UpdatePreparedStatement",
"athena:DeletePreparedStatement"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA"
}
]
}
```
------
### Exemplo: bloco de política que nega ações em um grupo de trabalho com base em par de chave e valor de tag
As tags associadas a um recurso, como um grupo de trabalho, são chamadas de tags de recurso. As tags de recursos permitem escrever blocos de política, como os seguintes, que negam as ações listadas em qualquer grupo de trabalho marcado com um par de chave-valor como `stack`, `production`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"athena:GetWorkGroup",
"athena:UpdateWorkGroup",
"athena:DeleteWorkGroup",
"athena:TagResource",
"athena:UntagResource",
"athena:ListTagsForResource",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:BatchGetQueryExecution",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResults",
"athena:GetQueryResultsStream",
"athena:CreateNamedQuery",
"athena:GetNamedQuery",
"athena:BatchGetNamedQuery",
"athena:ListNamedQueries",
"athena:DeleteNamedQuery",
"athena:CreatePreparedStatement",
"athena:GetPreparedStatement",
"athena:ListPreparedStatements",
"athena:UpdatePreparedStatement",
"athena:DeletePreparedStatement"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/stack": "production"
}
}
}
]
}
```
------
### Exemplo: bloco de política que restringe solicitações de ação de alteração de tag a tags específicas
As tags que são passadas como parâmetros para operações que alteram tags (por exemplo, `TagResource`, `UntagResource` ou `CreateWorkGroup` com tags) são chamadas de tags de solicitação. O seguinte exemplo de bloco de política permite a operação `CreateWorkGroup` apenas se uma das tags passadas tiver a chave `costcenter` e o valor `1`, `2` ou `3`.
**nota**
Se você deseja permitir que um perfil do IAM especifique as etiquetas como parte de uma operação `CreateWorkGroup`, certifique-se de conceder ao perfil as permissões para as ações `TagResource` e `CreateWorkGroup`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:CreateWorkGroup",
"athena:TagResource"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/costcenter": [
"1",
"2",
"3"
]
}
}
}
]
}
```
------
## Exemplos de políticas de etiquetas para catálogos de dados
### Exemplo: política básica de aplicação de tags
A seguinte política do IAM permite interagir com as etiquetas do catálogo de dados chamado `datacatalogA`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:ListEngineVersions",
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:GetDatabase",
"athena:ListTableMetadata",
"athena:GetTableMetadata"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:GetWorkGroup",
"athena:TagResource",
"athena:UntagResource",
"athena:ListTagsForResource",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:BatchGetQueryExecution",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResults",
"athena:GetQueryResultsStream",
"athena:CreateNamedQuery",
"athena:GetNamedQuery",
"athena:BatchGetNamedQuery",
"athena:ListNamedQueries",
"athena:DeleteNamedQuery"
],
"Resource": [
"arn:aws:athena:us-east-1:123456789012:workgroup/*"
]
},
{
"Effect": "Allow",
"Action": [
"athena:CreateDataCatalog",
"athena:GetDataCatalog",
"athena:UpdateDataCatalog",
"athena:DeleteDataCatalog",
"athena:ListDatabases",
"athena:GetDatabase",
"athena:ListTableMetadata",
"athena:GetTableMetadata",
"athena:TagResource",
"athena:UntagResource",
"athena:ListTagsForResource"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
}
]
}
```
------
### Exemplo: bloco de política que nega ações em um grupo de trabalho com base em um par de chave e valor de tag
Você pode usar tags de recursos para gravar blocos de política que negam ações específicas em catálogos de dados marcados com pares de chave-valor de tag específicos. O exemplo a seguir nega ações em catálogos de dados que têm o par de chave-valor da tag `stack`, `production`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"athena:CreateDataCatalog",
"athena:GetDataCatalog",
"athena:UpdateDataCatalog",
"athena:DeleteDataCatalog",
"athena:GetDatabase",
"athena:ListDatabases",
"athena:GetTableMetadata",
"athena:ListTableMetadata",
"athena:StartQueryExecution",
"athena:TagResource",
"athena:UntagResource",
"athena:ListTagsForResource"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:datacatalog/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/stack": "production"
}
}
}
]
}
```
------
### Exemplo: bloco de política que restringe solicitações de ação de alteração de tag a tags específicas
As tags que são passadas como parâmetros para operações que alteram tags (por exemplo, `TagResource`, `UntagResource` ou `CreateDataCatalog` com tags) são chamadas de tags de solicitação. O seguinte exemplo de bloco de política permite a operação `CreateDataCatalog` apenas se uma das tags passadas tiver a chave `costcenter` e o valor `1`, `2` ou `3`.
**nota**
Se você deseja permitir que um perfil do IAM especifique as etiquetas como parte de uma operação `CreateDataCatalog`, certifique-se de conceder ao perfil as permissões para as ações `TagResource` e `CreateDataCatalog`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:CreateDataCatalog",
"athena:TagResource"
],
"Resource": "arn:aws:athena:us-east-1:123456789012:datacatalog/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/costcenter": [
"1",
"2",
"3"
]
}
}
}
]
}
```
------
# Service Quotas
**nota**
O console do Service Quotas inclui informações sobre as cotas do Amazon Athena. Você também pode usar o console do Service Quotas para [solicitar aumentos de cotas](https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/athena/quotas) para aquelas que são ajustáveis. Para obter as limitações de esquema relacionadas ao AWS Glue, consulte a página [Endpoints e cotas do AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html). Para obter informações gerais sobre cotas de serviço da AWS, consulte [Cotas de serviço da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) na *Referência geral da AWS*.
## Consultas
Sua conta tem as seguintes cotas relacionadas a consultas para o Amazon Athena. Para obter detalhes, consulte a página [Endpoints e cotas do Amazon Athena](https://docs.aws.amazon.com/general/latest/gr/athena.html#amazon-athena-limits) da Referência geral da AWS.
+ **Active DDL queries** (Consultas DDL ativas): o número de consultas DDL ativas. As consultas DDL incluem consultas `CREATE TABLE` e `ALTER TABLE ADD PARTITION`.
+ **DDL query timeout** (Tempo limite de consulta DDL): a quantidade máxima de tempo em minutos que uma consulta DDL pode ser executada antes de ser cancelada.
+ **Active DML queries** (Consultas DML ativas): o número de consultas DML ativas. As consultas DML incluem consultas `SELECT`, `CREATE TABLE AS` (CTAS) e `INSERT INTO`. As cotas específicas variam de acordo com a região da AWS.
+ **DML query timeout** (Tempo limite de consulta DML): a quantidade máxima de tempo em minutos que uma consulta DML pode ser executada antes de ser cancelada. É possível solicitar um aumento desse tempo limite para até 240 minutos.
Para solicitar aumentos de cotas, você pode usar o console do [Service Quotas para o Athena](https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/athena/quotas).
O Athena processa as consultas atribuindo recursos com base na carga geral do serviço e no número de solicitações recebidas. Suas consultas podem ser temporariamente enfileiradas antes da execução. Os processos assíncronos retiram as consultas das filas e as executam nos recursos físicos assim que eles se tornam disponíveis e conforme permitido na configuração da sua conta.
As cotas para consultas em DML ativas e para consultas em DDL ativas incluem tanto as consultas em execução quanto as enfileiradas. Por exemplo, caso a cota para consultas em DML ativas seja 25 e o número total de consultas em execução e enfileiradas chegue a 26, a consulta de número 26 retornará um erro TooManyRequestsException.
**nota**
Se você deseja controlar a concorrência diretamente para as consultas que você executa no Athena, pode usar reservas de capacidade. Para obter mais informações, consulte [Gerenciar a capacidade de processamento de consulta](capacity-management.md).
### Comprimento da string de consulta
O comprimento máximo permitido da string da consulta é de 262.144 bytes, pois as strings são codificadas em UTF-8. Esta não é uma cota ajustável. No entanto, você pode resolver esse problema dividindo as consultas grandes em várias consultas menores. Para obter mais informações, consulte [Como posso aumentar o tamanho máximo da string de consulta no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-query-string-length/) (em inglês) na Central de Conhecimento da AWS.
## Grupos de trabalho
Ao usar os grupos de trabalho do Athena, lembre-se dos seguintes pontos:
+ As cotas do serviço do Athena são compartilhadas com todos os grupos de trabalho em uma conta.
+ O número máximo de grupos de trabalho que podem ser criados por região em uma conta é 1000.
+ O número máximo de instruções preparadas em um grupo de trabalho é mil.
+ O número máximo de tags por grupo de trabalho é 50. Para obter mais informações, consulte [Restrições de tags](tags.md#tag-restrictions).
## Bancos de dados, tabelas e partições
O Athena usa o AWS Glue Data Catalog. Consulte [Endpoints e cotas do AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html) para conhecer as cotas de serviço referentes a tabelas, bancos de dados e partições (por exemplo, o número máximo de bancos de dados ou de tabelas por conta). Observe que, embora o Athena ofereça suporte a consulta a tabelas do AWS Glue com 10 milhões de partições, ele não pode ler mais de 1 milhão de partições em uma única varredura.
## Buckets do Amazon S3
Ao trabalhar com buckets do Amazon S3, lembre-se dos seguintes pontos:
+ O Amazon S3 tem uma cota de serviço padrão de 10 mil buckets por conta.
+ O Athena requer um bucket separado para registrar os resultados.
+ É possível solicitar um aumento de cota de até um milhão de buckets do Amazon S3 por conta da AWS.
## Cotas de chamada de API por conta
As cotas padrão para as APIs do Athena se aplicam ao número de chamadas realizadas por conta, e não por consulta. Para obter uma lista completa das cotas padrão, consulte a tabela [Service quotas](https://docs.aws.amazon.com/general/latest/gr/athena.html#amazon-athena-limits) no guia de Referência geral da AWS.
Se você usar qualquer uma dessas APIs e exceder a cota padrão de número de chamadas por segundo ou a capacidade de expansão da sua conta, a API do Athena emitirá um erro semelhante ao seguinte: “ClientError: Ocorreu um erro (ThrottlingException) ao chamar a operação da **: taxa excedida.” Reduza o número de chamadas por segundo ou a capacidade de intermitência da API para essa conta.
É possível alterar a cota do Athena para as chamadas de API por conta no [console de Service Quotas do Athena](https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/athena/quotas).
# Versionamento do mecanismo do Athena