Como implantar o Grafana Loki e salvar dados no MinIO usando contêineres do Docker ou direto da fonte

Grafana Loki é um sistema de agregação de logs que armazena e consulta logs de aplicativos e infraestrutura. Embora comuns, os logs contêm informações críticas sobre as operações do sistema e são uma fonte valiosa de informações de depuração e solução de problemas. Os logs são frequentemente usados para identificar e rastrear atividades maliciosas ou simplesmente para rastrear a atividade do usuário para fornecer inteligência de negócios.

Em uma postagem de blog anterior, Registrando com Grafana Loki e MinIO , fornecemos uma visão geral dos componentes do Loki e sua arquitetura geral. Pense no Loki para logs como análogo ao Prometheus para métricas. O Loki é leve e econômico porque apenas indexa e consulta metadados. Os agentes Promtail coletam, rotulam e transformam logs antes de enviá-los para Loki. Em seguida, Loki indexa metadados e agrupa entradas em fluxos indexados com rótulos. O Grafana é então usado para visualizar e consultar informações de log do Loki. A partir da versão 2.0, o Loki armazena dados em um único back-end de armazenamento de objeto, como o MinIO. Enquanto a postagem anterior do blog explicava as vantagens de salvar os dados do Loki no MinIO, esta postagem do blog é um tutorial que ensina como.

Primeiro, ensinaremos como implantar Loki e MinIO usando contêineres Docker, seguidos de instruções sobre como instalar a partir do código-fonte.

Aprenda Loki e Master MinIO usando Docker Containers

Construímos uma demonstração usando contêineres Docker, alguns scripts e um repositório Git. Começamos com o repositório Grafana Loki e adicionamos yaml de configuração e contêineres para MinIO e um script para criar e expor um depósito MinIO para dados Loki. As etapas a seguir resultarão nessas cinco imagens sendo executadas localmente em contêineres do Docker:

• Loki
• Promtail
• Grafana
• MinIO
• Criar baldes

Os três primeiros são obviamente necessários para Loki, Promtail e Grafana. Eles já estavam disponíveis no Grafana no repositório Loki (há um pequeno vídeo explicativo ). MinIO é o armazenamento de objetos para o Loki, e o contêiner final executará um script que cria baldes como alvos do Loki.

Loki foi configurado para salvar dados de log em MinIO usando loki.yaml . De particular importância é a seção:

 storage_config: boltdb_shipper: active_index_directory: /loki/index cache_location: /loki/index_cache resync_interval: 5s shared_store: s3 aws: s3: http://minioadmin:minioadmin@minio.:9000/loki s3forcepathstyle: true

Observe o ponto no endereço S3 para MinIO. Isso é usado porque não há necessidade de especificar a região da AWS.

Criamos um ambiente Docker usando o arquivo docker-compose.yaml . Vamos configurar contêineres, volumes, portas, redes e fornecer comandos de inicialização.

Para que a imagem loki seja executada como um contêiner com acesso à configuração do Loki por meio de volumes:

 services: loki: image: grafana/loki:latest volumes: - <your-local-path>/loki/production:/home/loki/production ports: - "3100:3100" command: -config.file=/home/loki/production/loki.yaml networks: - loki

A primeira configuração que você precisará fazer é certificar-se de que sua pasta local de production está sendo compartilhada com o contêiner. Edite a seção volumes de seu docker-compose.yaml para se referir à pasta local no sistema host onde você baixou a pasta production . Estamos mapeando o caminho do host para o caminho do contêiner para ler loki.yaml .

Em docker-compose.yaml , também definimos uma rede e expomos as portas do contêiner executando o servidor MinIO. Nesse caso, as portas 9000 e 9001 serão expostas à sua máquina local para que você acesse o servidor MinIO com um navegador.

 Console UI: minio: image: minio/minio:latest ports: - "9000:9000" - "9001:9001" networks: - loki command: server ~ --address ':9000' --console-address ':9001'

Configuramos a rede com todos os containers compartilhando uma rede loki . Cada contêiner pode executar ping nos outros e usar suas APIs. Não use endereços IP fixos para seus contêineres. Para facilitar, configuramos loki e minio em nosso ambiente para resolver no contêiner apropriado. Por exemplo:

 http://minio:9000 for MinIO http://loki:3100 for Loki http://loki:3000 for Grafana

A próxima ação executada pelo docker-compose.yaml é executar o MinIO Client (mc) em um contêiner para configurar o MinIO Server, criar o bucket de destino para os dados do Loki e definir a política de acesso como public conforme necessário.

 createbuckets: image: minio/mc networks: - loki depends_on: - minio entrypoint: > /bin/sh -c " /usr/bin/mc config host add myminio http://minio:9000 minioadmin minioadmin; /usr/bin/mc rm -r --force myminio/loki; /usr/bin/mc mb myminio/loki; /usr/bin/mc policy set public myminio/loki; exit 0; "

Promtail, um pequeno programa Go, é usado para acompanhar ou coletar os arquivos de log distribuídos e entregá-los ao Loki. Para esta demonstração, o Promtail é implantado em seu contêiner com um arquivo de configuração que extrai o diretório /var/log. Nenhuma alteração é necessária para executar esta demonstração e processar os arquivos de log nesse local - /var/log.

No final deste tutorial, abordaremos como fazer com que o Promtail raspe outros locais no sistema para arquivos de log.

Passos

Agora que você entende como configurar Loki, Promtail e seu ambiente Docker, siga estas etapas para configurar e executar o ambiente de demonstração. As etapas a seguir usam docker-compose.yaml , loki.yaml e a configuração Promtail padrão para demonstrar como o Loki funciona com o MinIO. Após baixar nossos arquivos, edite-os para seu ambiente.

Clone este repositório https://github.com/cniackz/loki :

git clone https://github.com/cniackz/loki.git minio-loki-tutorial

Altere o diretório para sua pasta production local:

https://github.com/cniackz/loki/tree/main/production

 cd <your-local-path>/minio-loki-tutorial/production Edit docker-compose.yaml to reference your local home directory If necessary, edit promtail.yaml

Crie seu ambiente Docker local:

docker-compose build --no-cache

Inicie contêineres locais do Docker:

docker-compose up -d

Para confirmar que os dados do Loki estão sendo salvos no MinIO, faça login no MinIO Console em http://localhost:9001 ou http://minio:9001 . Este tutorial usa as seguintes credenciais:

 user: minioadmin password: minioadmin 

Depois de fazer login, clique em Baldes. Você deve ver que o balde Loki foi criado.

No lado direito, clique em Procurar para ver o conteúdo do bucket recém-criado. Você deve ver o diretório fake em loki . É aqui que Loki salvará os dados.

Clique em seu nome para abrir o diretório fake . O Loki mantém os logs na memória por um intervalo configurado e, em seguida, os grava no armazenamento de objetos. O padrão é um intervalo de 5 minutos, portanto, aguarde 5 minutos para que os dados apareçam em seu intervalo.

Neste ponto, o Promtail está enviando logs para o Loki e o Loki está salvando os dados no MinIO. Agora, vamos configurar o Grafana para visualizar os logs do Loki. Grafana 6.0 e superior incluem suporte integrado para Loki. O Grafana 6.3 e superior inclui suporte para a funcionalidade LogQL .

Faça login no Grafana em http://loki:3000 (as credenciais padrão são admin:admin).

No Grafana, clique no ícone de engrenagem na barra lateral esquerda para ir para Configuração e, em seguida, Fontes de dados. Clique no grande botão Adicionar fonte de dados e selecione Loki.

Edite o campo de URL http para o nosso servidor Loki em execução localmente usando o mapeamento de porta do Docker: http://loki:3100 .

Em seguida, clique em Salvar e testar.

Para ver os logs imediatamente, clique em explorar. Você também pode visualizar os logs clicando em Explorar na barra lateral esquerda. No entanto, você explora, selecione a fonte de dados Loki no menu suspenso superior esquerdo e escolha um fluxo de log usando o botão Log Labels.

Você pode digitar uma consulta LogQL e clicar em Executar consulta. No entanto, se você ainda não conhece o LogQL, pode usar a GUI para selecionar um log e parâmetros de consulta.

Para ver rapidamente os logs que estão no Loki, clique em Navegador de logs e em 1. Select labels to search in e escolha job e, em 2. Find values for the selected labels , clique no nome do seu trabalho (de promtail-local-config.yaml ). Neste caso, cliquei em varlogs . Em seguida, clique no botão Mostrar logs.

Você pode selecionar o intervalo de tempo e definir o intervalo de atualização da consulta no canto superior direito da janela do navegador.

Para ver mais detalhes dos logs, role para baixo e clique em uma das entradas de log, ele fornecerá informações adicionais relacionadas à entrada de log.

Um recurso realmente poderoso é a capacidade de filtrar ou ver estatísticas sobre labels e fields diretamente dos detalhes do log clicando nos ícones. Isso simplifica a solução de problemas, pois torna mais fácil procurar erros recorrentes e alternar entre os termos de pesquisa.

Estendendo a Demonstração

Depois que a demonstração estiver em execução, a próxima etapa é fazer com que o Promtail raspe um conjunto diferente de arquivos que possam ser mais interessantes para o seu caso de uso. Para fazer isso, precisamos que o Promtail seja executado usando um arquivo de configuração que possamos editar. Uma maneira de conseguir isso é usando volumes no Docker.

Edite o arquivo docker-compose.yaml para criar 2 novos volumes acessíveis a partir do contêiner Promtail. O primeiro fornece acesso ao diretório no sistema host onde o novo arquivo de configuração será criado. A segunda fornece acesso a um diretório que conterá os arquivos de log de interesse. Além disso, o Promtail será iniciado referenciando o novo arquivo de configuração, que chamamos de promtail-local-config.yaml :

 version: "3" networks: loki: services: loki: image: grafana/loki:latest volumes: - <your-local-path>/loki/minio-loki-tutorial/production:/home/loki/production ports: - "3100:3100" command: -config.file=/home/loki/production/loki.yaml networks: - loki promtail: image: grafana/promtail:2.4.2 volumes: - /var/log:/var/log -- <your-local-path>/loki/minio-loki-tutorial/production:/home/loki/production -- <your-local-path>/access_logs:/home/loki/access_logs command: -config.file=/home/loki/production/promtail-local-config.yaml networks: - loki grafana: image: grafana/grafana:latest ports: - "3000:3000" networks: - loki minio: image: minio/minio:latest ports: - "9000:9000" - "9001:9001" networks: - loki command: server ~ --address ':9000' --console-address ':9001' createbuckets: image: minio/mc networks: - loki depends_on: - minio entrypoint: > /bin/sh -c " /usr/bin/mc config host add myminio http://minio:9000 minioadmin minioadmin; /usr/bin/mc rm -r --force myminio/loki; /usr/bin/mc mb myminio/loki; /usr/bin/mc policy set public myminio/loki; exit 0; "

Há muito mais que você pode fazer com os dados de log no Grafana. Para começar, você pode instalar o promtail em mais lugares para seguir mais logs para o Loki. Copie o executável e promtail-local-config.yaml para outras máquinas/instâncias/contêineres, edite a configuração conforme descrito em Promtail Configuration e execute-o.

Agora precisamos criar o arquivo de configuração Promtail, promtail-local-config.yaml para enviar logs do sistema local para o Loki. Baixe e edite um arquivo de configuração de amostra do Grafana. A seção para focar é scrape_configs porque é onde o promtail é informado sobre quais logs extrair, como formatá-los e para onde enviá-los. Consulte Obter logs no Loki para obter mais informações sobre como configurar o promtail.

A seção scrape_configs inclui o seguinte:

• job_name - Isso diferencia os logs coletados de outros grupos de log.
• targets - Opcional para static_configs . No entanto, muitas vezes é definido porque em versões mais antigas do Promtail não era opcional. Este foi um artefato do uso direto do código de descoberta do serviço Prometheus, que exigia esta entrada.
• labels - Label estático para aplicar a cada linha de log extraída por esta definição. Bons exemplos incluem o nome do ambiente, o nome do trabalho ou o nome do aplicativo.
• caminho - O caminho para onde os logs que Loki deve consumir são armazenados.

 server: http_listen_port: 9080 grpc_listen_port: 0 positions: filename: /tmp/positions.yaml clients: - url: http://loki:3100/loki/api/v1/push scrape_configs: - job_name: apache static_configs: - targets: - localhost labels: job: access_logs __path__: /home/loki/access_logs/*log

É importante entender as diferentes opções de configuração para raspagem no Promtail, e o Grafana fornece muitos detalhes .

Pode ser útil consultar a referência de configuração promtail completa para ver todos os recursos do aplicativo.

Por fim, coloque alguns logs de acesso do servidor web Apache no diretório especificado no arquivo docker-compose.yaml no sistema host. Estes são os logs que o Promtail irá ingerir e enviar ao Loki para processamento:

-- <your-local-path>/access_logs:/home/loki/access_logs

Depois que as edições forem feitas e os logs de acesso do Apache de amostra estiverem em vigor, desative os contêineres e faça backup com o docker compose:

 docker-compose down docker-compose up -d

O Promtail carregará posteriormente os novos arquivos de log de acesso do Apache e os disponibilizará para Loki.

O ambiente que criamos neste tutorial é útil para começar a usar o Loki, mas não está pronto para produção. Os próximos passos seriam deixar o Docker para o Kubernetes e usar o MinIO distribuído em vez de uma única instância. Eventualmente, os dados do Loki ficam grandes o suficiente para se beneficiar de um banco de dados externo para pesquisas rápidas de índice. Consulte Escalabilidade - Dimensionamento com Grafana Loki para obter mais informações.

Conclusão

A pilha de observabilidade do Grafana, Prometheus e AlertManager ganhou uma adição poderosa com o Loki (aliás, também temos um tutorial para Grafana, Prometheus e AlertManager no MinIO ). Os sistemas distribuídos, especialmente quando conteinerizados e orquestrados pelo Kubernetes, possuem muitos logs para seus aplicativos e microsserviços. Loki combinado com MinIO é uma maneira econômica de coletar, armazenar e consultar logs.

Se você tiver alguma dúvida, envie-nos um e-mail para [email protected] ou entre no canal slack do MinIO e pergunte.