# Consultar logs do AWS WAF
O AWS WAF é um firewall para aplicações Web que permite monitorar e controlar as solicitações HTTP e HTTPS que as aplicações Web protegidas recebem dos clientes. Você define como lidar com as solicitações da Web configurando regras dentro de uma lista de controle de acesso (ACL) da Web do AWS WAF. Depois, você protege uma aplicação Web associando a ela uma ACL da Web. Exemplos de recursos de aplicações Web que você pode proteger com o AWS WAF incluem distribuições do Amazon CloudFront, APIs REST do Amazon API Gateway e Application Load Balancers. Para obter mais informações sobre o AWS WAF, consulte [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html) no *AWS WAF Developer Guide*.
Os logs do AWS WAF incluem informações sobre o tráfego que é analisado pela sua ACL da Web, como a hora em que o AWS WAF recebeu a solicitação do recurso da AWS, os detalhes da solicitação e a ação para a regra correspondente de cada solicitação.
Você pode configurar uma ACL da Web do AWS WAF para publicar logs em um de vários destinos, onde você pode consultá-los e visualizá-los. Para obter mais informações sobre a configuração de registro em log de ACL da Web e sobre o conteúdo dos logs do AWS WAF, consulte [Logging AWS WAF web ACL traffic](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) no *AWS WAF developer guide*.
Para obter informações sobre como usar o Athena para analisar logs do AWS WAF para obter informações sobre a detecção de ameaças e possíveis ataques à segurança, consulte a postagem do blog Networking & Content Delivery da AWS [Como usar as consultas do Amazon Athena para analisar logs do AWS WAF e fornecer a visibilidade necessária para a detecção de ameaças](https://aws.amazon.com/blogs/networking-and-content-delivery/how-to-use-amazon-athena-queries-to-analyze-aws-waf-logs-and-provide-the-visibility-needed-for-threat-detection/).
Para ver um exemplo de como agregar os logs do AWS WAF em um repositório central de data lake e consultá-los no Athena, leia a publicação em AWS Big Data Blog: [Analyzing AWS WAF logs with OpenSearch Service, Amazon Athena, and QuickSight](https://aws.amazon.com/blogs/big-data/analyzing-aws-waf-logs-with-amazon-es-amazon-athena-and-amazon-quicksight/).
Este tópico fornece exemplos de instruções `CREATE TABLE` para projeção de partições, particionamento manual e uma que não usa nenhum particionamento.
**nota**
As instruções `CREATE TABLE` neste tópico podem ser usadas para logs do AWS WAF v1 e v2. Na v1, o campo `webaclid` contém um ID. Na v2, o campo `webaclid` contém um ARN completo. As instruções `CREATE TABLE` aqui tratam esse conteúdo de forma agnóstica usando o tipo de dados `string`.
**Topics**
+ [Criar uma tabela para logs do S3 do AWS WAF no Athena usando a projeção de partições](create-waf-table-partition-projection.md)
+ [Criar uma tabela para logs do S3 do AWS WAF no Athena usando a partição manual](create-waf-table-manual-partition.md)
+ [Criar uma tabela para logs do AWS WAF sem particionamento](create-waf-table.md)
+ [Consultas de exemplo para logs do AWS WAF](query-examples-waf-logs.md)
# Criar uma tabela para logs do S3 do AWS WAF no Athena usando a projeção de partições
Como os logs do AWS WAF têm uma estrutura conhecida com um esquema de partição que você pode especificar antecipadamente, é possível reduzir o runtime das consultas e automatizar o gerenciamento de partições usando o recurso de [projeção de partições](partition-projection.md) do Athena. A projeção de partições adiciona automaticamente novas partições à medida que os dados são adicionados. Isso elimina a necessidade de adicionar manualmente as partições usando `ALTER TABLE ADD PARTITION`.
A instrução de exemplo `CREATE TABLE` a seguir usa automaticamente a projeção de partições com base nos logs do AWS WAF desde uma data especificada até o dia de hoje para diferentes regiões da AWS. A cláusula `PARTITION BY` neste exemplo particiona por região e data, mas você pode modificá-la de acordo com seus requisitos. Modifique os campos conforme necessário para corresponder à saída do log. Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados *amzn-s3-demo-bucket* e *AWS\$1ACCOUNT\$1NUMBER* por valores que identifiquem o local do bucket do Amazon S3 dos seus logs do AWS WAF. Em `projection.day.range`, substitua *2021*/*01*/*01* pela data de início que você desejar usar. Depois que você executar a consulta com êxito, poderá consultar a tabela. Você não precisa executar `ALTER TABLE ADD PARTITION` para carregar as partições.
```
CREATE EXTERNAL TABLE `waf_logs_partition_projection`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array>>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array>>>,nonterminatingmatchingrules:array>>,challengeresponse:struct,captcharesponse:struct>>,excludedrules:string>>,
`ratebasedrulelist` array>,
`nonterminatingmatchingrules` array>>,challengeresponse:struct,captcharesponse:struct>>,
`requestheadersinserted` array>,
`responsecodesent` string,
`httprequest` struct>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>,
`labels` array>,
`captcharesponse` struct,
`challengeresponse` struct,
`ja3fingerprint` string,
`ja4fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int)
PARTITIONED BY (
`log_time` string)
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/'
TBLPROPERTIES (
'projection.enabled'='true',
'projection.log_time.format'='yyyy/MM/dd/HH/mm',
'projection.log_time.interval'='1',
'projection.log_time.interval.unit'='minutes',
'projection.log_time.range'='2025/01/01/00/00,NOW',
'projection.log_time.type'='date',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/${log_time}')
```
**nota**
O formato do caminho na cláusula `LOCATION` no exemplo corresponde ao padrão, mas pode variar com base na configuração AWS WAF implementada. Por exemplo, o exemplo de caminho de log do AWS WAF a seguir é para uma distribuição do CloudFront:
```
s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/cloudfronyt/2025/01/01/00/00/
```
Se você tiver problemas ao criar ou consultar sua tabela de logs do AWS WAF, confirme a localização de seus dados de log ou [entre em contato com o Suporte](https://console.aws.amazon.com/support/home/).
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).
# Criar uma tabela para logs do S3 do AWS WAF no Athena usando a partição manual
Esta seção descreve como criar uma tabela para logs do AWS WAF usando a partição manual.
Nas cláusulas `LOCATION` e `storage.location.template`, substitua os espaços reservados *amzn-s3-demo-bucket* e *AWS\$1ACCOUNT\$1NUMBER* por valores que identifiquem o local do bucket do Amazon S3 dos seus logs do AWS WAF.
```
CREATE EXTERNAL TABLE `waf_logs_manual_partition`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array>>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array>>>,nonterminatingmatchingrules:array>>,challengeresponse:struct,captcharesponse:struct>>,excludedrules:string>>,
`ratebasedrulelist` array>,
`nonterminatingmatchingrules` array>>,challengeresponse:struct,captcharesponse:struct>>,
`requestheadersinserted` array>,
`responsecodesent` string,
`httprequest` struct>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>,
`labels` array>,
`captcharesponse` struct,
`challengeresponse` struct,
`ja3fingerprint` string,
`ja4fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int)
PARTITIONED BY ( `year` string, `month` string, `day` string, `hour` string, `min` string)
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/webacl/'
```
# Criar uma tabela para logs do AWS WAF sem particionamento
Esta seção descreve como criar uma tabela para logs do AWS WAF sem particionamento ou projeção de partição.
**nota**
Por motivos de desempenho e custo, não recomendamos usar o esquema não particionado para consultas. Para obter mais informações, consulte [Top 10 Performance Tuning Tips for Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) (As 10 melhores dicas para ajustar o desempenho do Amazon Athena) no AWS Big Data Blog.
**Como criar a tabela de AWS WAF**
1. Copie e cole a instrução DDL a seguir no console do Athena. Modifique os campos conforme necessário para corresponder à saída do log. Modifique o valor de `LOCATION` do bucket do Amazon S3 de forma que ele corresponda a uma localização que armazena seus logs.
Essa consulta usa o [OpenX JSON SerDe](openx-json-serde.md).
**nota**
O SerDe espera que cada documento JSON esteja em uma única linha de texto, sem caracteres de terminação de linha separando os campos no registro. Se o texto JSON estiver formatado para impressão, você poderá receber uma mensagem de erro como HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido) ou HIVE\$1CURSOR\$1ERROR: JsonParseException: Unexpected end-of-input: expected close marker for OBJECT (HIVE\$1CURSOR\$1ERROR: JSONParseException: Fim de entrada inesperado: marcador de fechamento esperado para OBJECT) quando tentar consultar a tabela após criá-la. Para obter mais informações, consulte [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) na documentação do OpenX SerDe no GitHub.
```
CREATE EXTERNAL TABLE `waf_logs`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array <
struct <
rulegroupid: string,
terminatingrule: struct <
ruleid: string,
action: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>
>,
nonterminatingmatchingrules: array <
struct <
ruleid: string,
action: string,
overriddenaction: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
challengeresponse: struct <
responsecode: string,
solvetimestamp: string
>,
captcharesponse: struct <
responsecode: string,
solvetimestamp: string
>
>
>,
excludedrules: string
>
>,
`ratebasedrulelist` array <
struct <
ratebasedruleid: string,
limitkey: string,
maxrateallowed: int
>
>,
`nonterminatingmatchingrules` array <
struct <
ruleid: string,
action: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
challengeresponse: struct <
responsecode: string,
solvetimestamp: string
>,
captcharesponse: struct <
responsecode: string,
solvetimestamp: string
>
>
>,
`requestheadersinserted` array <
struct <
name: string,
value: string
>
>,
`responsecodesent` string,
`httprequest` struct <
clientip: string,
country: string,
headers: array <
struct <
name: string,
value: string
>
>,
uri: string,
args: string,
httpversion: string,
httpmethod: string,
requestid: string
>,
`labels` array <
struct <
name: string
>
>,
`captcharesponse` struct <
responsecode: string,
solvetimestamp: string,
failureReason: string
>,
`challengeresponse` struct <
responsecode: string,
solvetimestamp: string,
failureReason: string
>,
`ja3Fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/prefix/'
```
1. Execute a instrução `CREATE EXTERNAL TABLE` no editor de consultas do console do Athena. Isso registra a tabela `waf_logs` e disponibiliza os dados dela para consultas no Athena.
# Consultas de exemplo para logs do AWS WAF
Muitos dos exemplos de consultas nesta seção usam a tabela de projeção de partições criada anteriormente. Modifique o nome da tabela, os valores das colunas e outras variáveis de acordo com os seus requisitos. Para melhorar a performance das suas consultas e reduzir os custos, adicione a coluna de partição à condição de filtro.
**Topics**
+ [Contar indicadores, endereços IP ou regras correspondentes](query-examples-waf-logs-count.md)
+ [Consultar usando data e hora](query-examples-waf-logs-date-time.md)
+ [Consultar solicitações ou endereços bloqueados](query-examples-waf-logs-blocked-requests.md)
# Contar indicadores, endereços IP ou regras correspondentes
Os exemplos nesta seção consultam contagens de itens de log de interesse.
+ [Count the number of referrers that contain a specified term](#waf-example-count-referrers-with-specified-term)
+ [Count all matched IP addresses in the last 10 days that have matched excluded rules](#waf-example-count-matched-ip-addresses)
+ [Group all counted managed rules by the number of times matched](#waf-example-group-managed-rules-by-times-matched)
+ [Group all counted custom rules by number of times matched](#waf-example-group-custom-rules-by-times-matched)
**Example – Contar o número de indicadores que contêm um termo especificado**
A consulta a seguir conta o número de indicadores que contêm o termo “amazon” para o intervalo de datas especificado.
```
WITH test_dataset AS
(SELECT header FROM waf_logs
CROSS JOIN UNNEST(httprequest.headers) AS t(header) WHERE "date" >= '2021/03/01'
AND "date" < '2021/03/31')
SELECT COUNT(*) referer_count
FROM test_dataset
WHERE LOWER(header.name)='referer' AND header.value LIKE '%amazon%'
```
**Example – Contar todos os endereços IP que corresponderam a regras excluídas nos últimos 10 dias**
A consulta a seguir conta o número de vezes nos últimos 10 dias que o endereço IP correspondeu à regra excluída no grupo de regras.
```
WITH test_dataset AS
(SELECT * FROM waf_logs
CROSS JOIN UNNEST(rulegrouplist) AS t(allrulegroups))
SELECT
COUNT(*) AS count,
"httprequest"."clientip",
"allrulegroups"."excludedrules",
"allrulegroups"."ruleGroupId"
FROM test_dataset
WHERE allrulegroups.excludedrules IS NOT NULL AND from_unixtime(timestamp/1000) > now() - interval '10' day
GROUP BY "httprequest"."clientip", "allrulegroups"."ruleGroupId", "allrulegroups"."excludedrules"
ORDER BY count DESC
```
**Example – Agrupar todas as regras gerenciadas contadas pelo número de vezes de correspondência**
Se você definiu as ações de regras do grupo de regras como Count na configuração de ACL da Web antes de 27 de outubro de 2022, o AWS WAF salvou suas substituições no JSON da ACL da Web como `excludedRules`. Agora, a configuração JSON para substituir uma regra para Count está nas configurações `ruleActionOverrides`. Para obter mais informações, consulte [Substituições de ações em grupos de regras](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-rule-group-override-options.html) no *Guia do desenvolvedor do AWS WAF*. Para extrair regras gerenciadas no modo Count da nova estrutura de logs, consulte `nonTerminatingMatchingRules` na seção `ruleGroupList` em vez do campo `excludedRules`, como no exemplo a seguir.
```
SELECT
count(*) AS count,
httpsourceid,
httprequest.clientip,
t.rulegroupid,
t.nonTerminatingMatchingRules
FROM "waf_logs"
CROSS JOIN UNNEST(rulegrouplist) AS t(t)
WHERE action <> 'BLOCK' AND cardinality(t.nonTerminatingMatchingRules) > 0
GROUP BY t.nonTerminatingMatchingRules, action, httpsourceid, httprequest.clientip, t.rulegroupid
ORDER BY "count" DESC
Limit 50
```
**Example – Agrupar todas as regras personalizadas contadas pelo número de vezes de correspondência**
A consulta a seguir agrupa todas as regras personalizadas contadas pelo número de vezes de correspondência.
```
SELECT
count(*) AS count,
httpsourceid,
httprequest.clientip,
t.ruleid,
t.action
FROM "waf_logs"
CROSS JOIN UNNEST(nonterminatingmatchingrules) AS t(t)
WHERE action <> 'BLOCK' AND cardinality(nonTerminatingMatchingRules) > 0
GROUP BY t.ruleid, t.action, httpsourceid, httprequest.clientip
ORDER BY "count" DESC
Limit 50
```
Para obter informações sobre os locais de log de regras personalizadas e grupos de regras gerenciados, consulte [Monitoramento e ajuste](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-testing-activities.html) no *Guia do desenvolvedor do AWS WAF*.
# Consultar usando data e hora
Os exemplos desta seção incluem consultas que usam valores de data e hora.
+ [Return the timestamp field in human-readable ISO 8601 format](#waf-example-return-human-readable-timestamp)
+ [Return records from the last 24 hours](#waf-example-return-records-last-24-hours)
+ [Return records for a specified date range and IP address](#waf-example-return-records-date-range-and-ip)
+ [For a specified date range, count the number of IP addresses in five minute intervals](#waf-example-count-ip-addresses-in-date-range)
+ [Count the number of X-Forwarded-For IP in the last 10 days](#waf-example-count-x-forwarded-for-ip)
**Example – Retornar o campo de carimbo de data/hora no formato ISO 8601 legível**
A consulta a seguir usa as funções `from_unixtime` e `to_iso8601` para retornar o campo `timestamp` no formato ISO 8601 legível (por exemplo, `2019-12-13T23:40:12.000Z` em vez de `1576280412771`). A consulta também retorna o nome, o ID e a solicitação da fonte HTTP.
```
SELECT to_iso8601(from_unixtime(timestamp / 1000)) as time_ISO_8601,
httpsourcename,
httpsourceid,
httprequest
FROM waf_logs
LIMIT 10;
```
**Example – Retornar os registros das últimas 24 horas**
A consulta a seguir usa um filtro na cláusula `WHERE` para retornar o nome, o ID e os campos de solicitação da fonte HTTP dos registros nas últimas 24 horas.
```
SELECT to_iso8601(from_unixtime(timestamp/1000)) AS time_ISO_8601,
httpsourcename,
httpsourceid,
httprequest
FROM waf_logs
WHERE from_unixtime(timestamp/1000) > now() - interval '1' day
LIMIT 10;
```
**Example – Retornar os registros para um intervalo de datas e endereço IP especificados**
A consulta a seguir lista os registros em um intervalo de datas especificado para um endereço IP de cliente especificado.
```
SELECT *
FROM waf_logs
WHERE httprequest.clientip='53.21.198.66' AND "date" >= '2021/03/01' AND "date" < '2021/03/31'
```
**Example – Para um intervalo de datas especificado, contar o número de endereços IP em intervalos de cinco minutos**
A consulta a seguir conta, durante um determinado intervalo de datas, o número de endereços IP em intervalos de cinco minutos.
```
WITH test_dataset AS
(SELECT
format_datetime(from_unixtime((timestamp/1000) - ((minute(from_unixtime(timestamp / 1000))%5) * 60)),'yyyy-MM-dd HH:mm') AS five_minutes_ts,
"httprequest"."clientip"
FROM waf_logs
WHERE "date" >= '2021/03/01' AND "date" < '2021/03/31')
SELECT five_minutes_ts,"clientip",count(*) ip_count
FROM test_dataset
GROUP BY five_minutes_ts,"clientip"
```
**Example – Contar o número de X-Forwarded-For IP nos últimos 10 dias**
A consulta a seguir filtra os cabeçalhos de solicitação e conta o número de X-Forwarded-For IP nos últimos 10 dias.
```
WITH test_dataset AS
(SELECT header
FROM waf_logs
CROSS JOIN UNNEST (httprequest.headers) AS t(header)
WHERE from_unixtime("timestamp"/1000) > now() - interval '10' DAY)
SELECT header.value AS ip,
count(*) AS COUNT
FROM test_dataset
WHERE header.name='X-Forwarded-For'
GROUP BY header.value
ORDER BY COUNT DESC
```
Para obter mais informações sobre as funções de data e hora, consulte [Date and Time Functions and Operators](https://trino.io/docs/current/functions/datetime.html) (Funções e operadores de data e hora) na documentação do Trino.
# Consultar solicitações ou endereços bloqueados
Os exemplos desta seção consultam solicitações ou endereços bloqueados.
+ [Extract the top 100 IP addresses blocked by a specified rule type](#waf-example-extract-top-100-blocked-ip-by-rule)
+ [Count the number of times a request from a specified country has been blocked](#waf-example-count-request-blocks-from-country)
+ [Count the number of times a request has been blocked, grouping by specific attributes](#waf-example-count-request-blocks-by-attribute)
+ [Count the number of times a specific terminating rule ID has been matched](#waf-example-count-terminating-rule-id-matches)
+ [Retrieve the top 100 IP addresses blocked during a specified date range](#waf-example-top-100-ip-addresses-blocked-for-date-range)
**Example – Extrair os 100 primeiros endereços IP bloqueados por um tipo de regra especificado**
A consulta a seguir extrai e conta os 100 primeiros endereços IP que foram bloqueados pela regra de encerramento `RATE_BASED` durante o intervalo de datas especificado.
```
SELECT COUNT(httpRequest.clientIp) as count,
httpRequest.clientIp
FROM waf_logs
WHERE terminatingruletype='RATE_BASED' AND action='BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY httpRequest.clientIp
ORDER BY count DESC
LIMIT 100
```
**Example – Contar o número de vezes que uma solicitação foi bloqueada de um país especificado**
A consulta a seguir conta o número de vezes que a solicitação chegou de um endereço IP pertencente à Irlanda (IE) e foi bloqueada pela regra de encerramento `RATE_BASED`.
```
SELECT
COUNT(httpRequest.country) as count,
httpRequest.country
FROM waf_logs
WHERE
terminatingruletype='RATE_BASED' AND
httpRequest.country='IE'
GROUP BY httpRequest.country
ORDER BY count
LIMIT 100;
```
**Example – Contar o número de vezes que uma solicitação foi bloqueada, agrupando por atributos específicos**
A consulta a seguir conta o número de vezes que a solicitação foi bloqueada, com resultados agrupados por WebACL, RuleId, ClientIP e HTTP Request URI.
```
SELECT
COUNT(*) AS count,
webaclid,
terminatingruleid,
httprequest.clientip,
httprequest.uri
FROM waf_logs
WHERE action='BLOCK'
GROUP BY webaclid, terminatingruleid, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```
**Example – Contar o número de vezes em que houve correspondência com um ID de regra de encerramento específico**
A consulta a seguir conta o número de vezes que um ID de regra de encerramento específico foi correspondido (`WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'`). A consulta agrupa os resultados por WebACL, Action, ClientIP e HTTP Request URI.
```
SELECT
COUNT(*) AS count,
webaclid,
action,
httprequest.clientip,
httprequest.uri
FROM waf_logs
WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'
GROUP BY webaclid, action, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```
**Example – Recuperar os 100 primeiros endereços IP bloqueados durante um intervalo de datas especificado**
A consulta a seguir extrai os 100 primeiros endereços IP que foram bloqueados durante um intervalo de datas especificado. A consulta também lista o número de vezes que os endereços IP foram bloqueados.
```
SELECT "httprequest"."clientip", "count"(*) "ipcount", "httprequest"."country"
FROM waf_logs
WHERE "action" = 'BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY "httprequest"."clientip", "httprequest"."country"
ORDER BY "ipcount" DESC limit 100
```