Tutorial do Comando awk do Linux: Processamento de Texto Avançado

Introdução

Bem-vindo ao mundo do processamento de texto com AWK. Neste laboratório, você aprenderá a usar o comando awk para analisar arquivos de log, uma tarefa comum para administradores de sistemas e analistas de dados. O AWK é uma ferramenta poderosa para processar dados de texto estruturados no Linux, permitindo extrair, filtrar e transformar informações de maneira eficiente.

Imagine que você é um administrador de sistemas júnior encarregado de analisar os logs do servidor para identificar possíveis ameaças de segurança e problemas de desempenho. O comando awk será sua principal ferramenta para essa tarefa, permitindo que você examine rapidamente grandes arquivos de log e extraia insights significativos.

Este é um Laboratório Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para concluir cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 93%. Ele recebeu uma taxa de avaliação positiva de 96% dos alunos.

Examinando o Arquivo de Log

Vamos começar examinando o conteúdo do nosso arquivo de log de exemplo. Este arquivo contém logs simulados de acesso ao servidor que analisaremos ao longo deste laboratório.

Primeiro, navegue até o diretório do projeto:

cd ~/project

Agora, vamos visualizar as primeiras linhas do arquivo de log:

head -n 5 server_logs.txt

Você deverá ver uma saída semelhante a esta:

2023-08-01 08:15:23 192.168.1.100 GET /index.html 200
2023-08-01 08:16:45 192.168.1.101 GET /about.html 200
2023-08-01 08:17:30 192.168.1.102 POST /login.php 302
2023-08-01 08:18:12 192.168.1.103 GET /products.html 404
2023-08-01 08:19:05 192.168.1.104 GET /services.html 200

Este arquivo de log contém informações sobre requisições ao servidor, incluindo data e hora, endereço IP, método HTTP, recurso solicitado e código de status.

Uso Básico do AWK - Imprimindo Campos Específicos

Agora que vimos a estrutura do nosso arquivo de log, vamos usar o AWK para extrair informações específicas. Por padrão, o AWK divide cada linha em campos com base em espaços em branco. Podemos nos referir a esses campos usando $1, $2, etc., onde $1 é o primeiro campo, $2 é o segundo, e assim por diante.

Vamos extrair os endereços IP (o terceiro campo) do nosso arquivo de log:

awk '{print $3}' server_logs.txt | head -n 5

Você deverá ver uma saída semelhante a esta:

192.168.1.100
192.168.1.101
192.168.1.102
192.168.1.103
192.168.1.104

Neste comando:

awk '{print $3}' diz ao AWK para imprimir o terceiro campo de cada linha.
Usamos o pipe (|) para enviar a saída para head -n 5 para limitar a exibição às primeiras 5 linhas.

Agora, vamos imprimir tanto o endereço IP quanto o recurso solicitado:

awk '{print $3, $5}' server_logs.txt | head -n 5

Saída:

192.168.1.100 /index.html
192.168.1.101 /about.html
192.168.1.102 /login.php
192.168.1.103 /products.html
192.168.1.104 /services.html

Aqui, estamos imprimindo o terceiro campo (endereço IP) e o quinto campo (recurso solicitado) para cada linha.

Filtrando Entradas de Log

Um dos pontos fortes do AWK é sua capacidade de filtrar dados com base em condições. Vamos usar esse recurso para encontrar todas as requisições POST em nosso arquivo de log, pois elas podem ser mais sensíveis à segurança do que as requisições GET.

Execute o seguinte comando:

awk '$4 == "POST" {print $0}' server_logs.txt

Vamos detalhar a sintaxe deste comando para entender como funciona a filtragem no AWK:

$4 == "POST" - Este é um padrão ou condição que o AWK avalia para cada linha:
- $4 refere-se ao quarto campo na linha atual (em nosso arquivo de log, este é o método HTTP)
- == é o operador de igualdade que verifica se dois valores são iguais
- "POST" é a string com a qual estamos comparando
{print $0} - Esta é a ação que o AWK executa quando a condição é verdadeira:
- As chaves {} envolvem a ação
- print é o comando para exibir texto
- $0 representa a linha atual inteira (todos os campos)

A estrutura do comando segue o padrão AWK: condição {ação}. O AWK lê cada linha e, se a condição for avaliada como verdadeira, ele executa a ação. Se nenhuma condição for especificada (como em nossos exemplos anteriores), a ação é executada para cada linha.

Você deverá ver uma saída semelhante a esta:

2023-08-01 08:17:30 192.168.1.102 POST /login.php 302
2023-08-01 09:23:45 192.168.1.110 POST /submit_form.php 200
2023-08-01 10:45:12 192.168.1.115 POST /upload.php 500

Agora, vamos encontrar todas as requisições que resultaram em um status 404 (Não Encontrado):

awk '$6 == "404" {print $1, $2, $5}' server_logs.txt

Este comando segue o mesmo padrão, mas com valores diferentes:

A condição $6 == "404" verifica se o sexto campo (código de status) é igual a 404
A ação {print $1, $2, $5} imprime apenas campos específicos:
- $1 - Primeiro campo (data)
- $2 - Segundo campo (hora)
- $5 - Quinto campo (recurso solicitado)

Essa impressão seletiva permite que você se concentre apenas nas informações necessárias.

Saída:

2023-08-01 08:18:12 /products.html
2023-08-01 09:30:18 /nonexistent.html
2023-08-01 11:05:30 /missing_page.html

Você pode combinar várias condições usando operadores lógicos:

&& para E (ambas as condições devem ser verdadeiras)
|| para OU (pelo menos uma condição deve ser verdadeira)
! para NÃO (nega uma condição)

Por exemplo, para encontrar todas as requisições POST que resultaram em erro (código de status >= 400):

awk '$4 == "POST" && $6 >= 400 {print $0}' server_logs.txt

Esses filtros podem ajudá-lo a identificar rapidamente problemas potenciais ou atividades suspeitas nos logs do seu servidor.

Contagem e Sumarização de Dados

O AWK é excelente para contar ocorrências e resumir dados. Vamos usá-lo para contar o número de requisições para cada código de status HTTP.

Execute este comando:

awk '{count[$6]++} END {for (code in count) print code, count[code]}' server_logs.txt | sort -n

Este comando é mais complexo, então vamos analisá-lo passo a passo:

{count[$6]++} - Esta é a ação principal executada para cada linha:
- count é um array (array associativo ou dicionário) que estamos criando
- [$6] usa o valor do 6º campo (código de status) como o índice/chave do array
- ++ é o operador de incremento, adicionando 1 ao valor atual
- Assim, para cada linha, incrementamos o contador para o código de status específico encontrado
END {for (code in count) print code, count[code]} - Isso é executado após o processamento de todas as linhas:
- END é um padrão especial que corresponde ao final da entrada
- {...} contém a ação a ser executada após todo o processamento da entrada
- for (code in count) é um loop que itera por todas as chaves no array count
- print code, count[code] imprime cada código de status e sua respectiva contagem
| sort -n - Envia a saída para o comando sort, que ordena numericamente

Quando o AWK processa um array como count[$6]++, ele automaticamente:

Cria o array se ele não existir
Cria um novo elemento com valor 0 se a chave não existir
Em seguida, incrementa o valor em 1

Você deverá ver uma saída semelhante a esta:

Este resumo mostra rapidamente a distribuição dos códigos de status no seu arquivo de log.

Agora, vamos encontrar os 5 recursos acessados com mais frequência:

awk '{count[$5]++} END {for (resource in count) print count[resource], resource}' server_logs.txt | sort -rn | head -n 5

Este comando segue um padrão semelhante com algumas alterações:

{count[$5]++} - Conta as ocorrências do 5º campo (o recurso solicitado)
END {for (resource in count) print count[resource], resource} - Após processar todas as linhas:
- Imprime a contagem primeiro, seguida pelo recurso
- Essa mudança de ordem facilita a ordenação numérica pela contagem
| sort -rn - Ordena numericamente em ordem reversa (maiores contagens primeiro)
| head -n 5 - Limita a saída às primeiras 5 linhas (os 5 principais resultados)

Saída:

1823 /index.html
956 /about.html
743 /products.html
512 /services.html
298 /contact.html

Esses comandos AWK demonstram o poder do uso de arrays para contagem e sumarização. Você pode adaptar esse padrão para contar qualquer campo ou combinação de campos em seus dados.

Por exemplo, para contar o número de requisições por endereço IP:

awk '{count[$3]++} END {for (ip in count) print ip, count[ip]}' server_logs.txt

Para contar requisições tanto por método quanto por status:

awk '{key=$4"-"$6; count[key]++} END {for (k in count) print k, count[k]}' server_logs.txt

Esses resumos podem ajudá-lo a entender os padrões de tráfego e identificar recursos populares (ou problemáticos) em seu servidor.

Criando um Relatório Simples

Para nossa tarefa final, vamos criar um relatório HTML simples resumindo algumas informações importantes do nosso arquivo de log. Usaremos um script AWK armazenado em um arquivo separado para esta operação mais complexa.

Primeiro, crie um arquivo chamado log_report.awk com o seguinte conteúdo:

Dica: Copie o conteúdo abaixo e cole no seu terminal para criar o arquivo.

cat << 'EOF' > log_report.awk
BEGIN {
    print "<html><body>"
    print "<h1>Server Log Summary</h1>"
    total = 0
    errors = 0
}

{
    total++
    if ($6 >= 400) errors++
    ip_count[$3]++
    resource_count[$5]++
}

END {
    print "<p>Total requests: " total "</p>"
    print "<p>Error rate: " (errors/total) * 100 "%</p>"
    
    print "<h2>Top 5 IP Addresses</h2>"
    print "<ul>"
    for (ip in ip_count) {
        top_ips[ip] = ip_count[ip]
    }
    n = asort(top_ips, sorted_ips, "@val_num_desc")
    for (i = 1; i <= 5 && i <= n; i++) {
        for (ip in ip_count) {
            if (ip_count[ip] == sorted_ips[i]) {
                print "<li>" ip ": " ip_count[ip] " requests</li>"
                break
            }
        }
    }
    print "</ul>"
    
    print "<h2>Top 5 Requested Resources</h2>"
    print "<ul>"
    for (resource in resource_count) {
        top_resources[resource] = resource_count[resource]
    }
    n = asort(top_resources, sorted_resources, "@val_num_desc")
    for (i = 1; i <= 5 && i <= n; i++) {
        for (resource in resource_count) {
            if (resource_count[resource] == sorted_resources[i]) {
                print "<li>" resource ": " resource_count[resource] " requests</li>"
                break
            }
        }
    }
    print "</ul>"
    
    print "</body></html>"
}
EOF

Vamos entender este script AWK seção por seção:

Bloco BEGIN: Executado antes de processar qualquer linha de entrada

BEGIN {
    print "<html><body>"  ## Inicia a estrutura HTML
    print "<h1>Server Log Summary</h1>"
    total = 0  ## Inicializa o contador para o total de requisições
    errors = 0  ## Inicializa o contador para requisições com erro
}

Bloco de Processamento Principal: Executado para cada linha do arquivo de entrada

{
    total++  ## Incrementa o contador total de requisições
    if ($6 >= 400) errors++  ## Conta respostas de erro (códigos de status >= 400)
    ip_count[$3]++  ## Conta requisições por endereço IP (campo 3)
    resource_count[$5]++  ## Conta requisições por recurso (campo 5)
}

Bloco END: Executado após o processamento de todas as linhas de entrada

END {
    ## Imprime estatísticas resumidas
    print "<p>Total requests: " total "</p>"
    print "<p>Error rate: " (errors/total) * 100 "%</p>"

    ## Processa e imprime os 5 principais endereços IP
    ## ...

    ## Processa e imprime os 5 principais recursos solicitados
    ## ...

    print "</body></html>"  ## Finaliza a estrutura HTML
}

Vamos examinar a lógica de ordenação para os principais IPs (a seção de recursos funciona da mesma maneira):

## Copia as contagens para um novo array para ordenação
for (ip in ip_count) {
    top_ips[ip] = ip_count[ip]
}

## Ordena o array pelo valor em ordem decrescente
n = asort(top_ips, sorted_ips, "@val_num_desc")

## Imprime as 5 principais entradas
for (i = 1; i <= 5 && i <= n; i++) {
    ## Encontra o IP original que corresponde a esta contagem
    for (ip in ip_count) {
        if (ip_count[ip] == sorted_ips[i]) {
            print "<li>" ip ": " ip_count[ip] " requests</li>"
            break
        }
    }
}

Neste script:

A função asort() ordena o array
"@val_num_desc" é um argumento especial que instrui a ordenação numérica pelo valor em ordem decrescente
Os loops aninhados encontram e imprimem as 5 principais entradas

Agora, vamos executar nosso script AWK para gerar o relatório:

awk -f log_report.awk server_logs.txt > log_report.html

A opção -f diz ao AWK para ler o script do arquivo especificado:

-f log_report.awk - Lê o script AWK do arquivo log_report.awk
server_logs.txt - Processa este arquivo usando o script
> log_report.html - Redireciona a saída para o arquivo log_report.html

Você pode visualizar o conteúdo do relatório usando o comando cat:

cat log_report.html

Este relatório fornece um resumo do total de requisições, taxa de erro, os 5 principais endereços IP e os 5 principais recursos solicitados. Em um cenário real, você poderia abrir este arquivo HTML em um navegador web para uma visualização formatada.

A abordagem que usamos neste script demonstra como o AWK pode ser usado para tarefas de análise de dados mais complexas. Você pode estender este script para incluir estatísticas adicionais ou diferentes visualizações com base em suas necessidades específicas.

Resumo

Parabéns! Você concluiu este laboratório sobre o uso do comando AWK para análise de logs. Vamos recapitular o que você aprendeu:

Uso básico do AWK: Imprimir campos específicos de um arquivo de texto estruturado.
Filtragem de dados: Usar condições no AWK para selecionar entradas de log específicas.
Contagem e sumarização: Usar o AWK para gerar estatísticas a partir de dados de log.
Criação de relatórios: Escrever scripts AWK mais complexos para gerar relatórios formatados.

Essas habilidades serão inestimáveis para analisar arquivos de log, processar dados e gerar relatórios em seu trabalho futuro como administrador de sistemas ou analista de dados.

Aqui estão alguns parâmetros e recursos adicionais do AWK que não cobrimos neste laboratório:

-F: Especifica um separador de campos diferente de espaço em branco.
-v: Atribui um valor a uma variável.
NR: Uma variável integrada que representa o número do registro atual.
NF: Uma variável integrada que representa o número de campos no registro atual.
Blocos BEGIN e END: Padrões especiais para inicialização e finalização.
Funções integradas: Funções matemáticas, funções de string e muito mais.

Lembre-se, a prática é fundamental para dominar o AWK. Tente modificar os comandos e scripts deste laboratório para analisar diferentes aspectos do arquivo de log ou para processar outros tipos de dados de texto estruturados.

Recursos

Linux Roadmap - roadmap.sh