Como instalar o Loki Stack em um cluster DOKS

Introdução

No gerenciamento de orquestração do Kubernetes, o stack Loki provou ser uma solução de registro leve e poderosa. Ele gerencia perfeitamente o fluxo de registros em um cluster Kubernetes, oferecendo escalabilidade e alta disponibilidade.

Neste tutorial, você aprenderá sobre Loki, que é um sistema de agregação de registros inspirado no Prometheus.

Índice

• Introdução
• Pré-requisitos
• Passo 1 – Instalando o LOKI
• Passo 2 – Configurando o Grafana com o Loki
• Passo 3 – Usando LogQL
• Passo 4 – Entendendo o Promtail
• Passo 5 – Configurando Armazenamento Persistente para o Loki
• Passo 6 – Definindo a Retenção de Armazenamento do Loki
• Conclusão

Pré-requisitos

Para completar este tutorial, você precisará de:

1. A DO Spaces bucket for Loki storage. Please follow the official DigitalOcean tutorial to create one. Make sure that it is set to restrict file listing for security reasons.
2. Chaves de acesso para DO Spaces (armazenamento de objeto compatível com S3). Siga o tutorial oficial da DigitalOcean para aprender como gerenciar chaves de acesso. Mantenha as chaves de acesso e secreta em um local seguro para uso posterior.
3. A Git client, for cloning the Starter Kit repository.
4. Helm, para instalar o gráfico do stack Loki.
5. Kubectl para interação com o Kubernetes.
6. A text editor with YAML lint support, for example: Visual Studio Code.
7. Aplicativo de Exemplo Emojivoto implantado no cluster. Siga as etapas no README do repositório correspondente.

Passo 1 – Instalando LOKI

Neste passo, você aprenderá como implantar o Loki no seu cluster DOKS, usando o Helm.

Primeiro, clone o repositório Starter Kit e, em seguida, altere o diretório para sua cópia local:

git clone https://github.com/digitalocean/Kubernetes-Starter-Kit-Developers.git

cd Kubernetes-Starter-Kit-Developers

Em seguida, adicione o repositório Helm do Grafana e liste os gráficos disponíveis:

helm repo add grafana https://grafana.github.io/helm-charts

helm repo update grafana

helm search repo grafana

A saída se parece com o seguinte:

NAME                                            CHART VERSION   APP VERSION     DESCRIPTION
grafana/grafana                                 6.20.5          8.3.4           The leading tool for querying and visualizing t...
grafana/enterprise-metrics                      1.7.2           v1.6.1         Grafana Enterprise Metrics
grafana/fluent-bit                              2.3.0           v2.1.0          Uses fluent-bit Loki go plugin for gathering lo...
grafana/loki-stack                              2.6.4           v2.4.2          Loki: like Prometheus, but for logs.
...

Para sua conveniência, há um arquivo de valores de amostra pronto para uso fornecido no repositório Git do Starter Kit (loki-stack-values-v2.6.4.yaml). Por favor, use seu editor de texto favorito (de preferência com suporte a lint YAML) para inspeção.

code 04-setup-observability/assets/manifests/loki-stack-values-v2.6.4.yaml

Em seguida, instale o stack usando helm. O seguinte comando instala a versão 2.6.4 do grafana/loki-stack em seu cluster usando o arquivo de valores do repositório Starter Kit. Isso também cria o namespace loki-stack se ele ainda não existir.

HELM_CHART_VERSION="2.6.4"

helm install loki grafana/loki-stack --version "${HELM_CHART_VERSION}" \
  --namespace=loki-stack \
  --create-namespace \
  -f "04-setup-observability/assets/manifests/loki-stack-values-v${HELM_CHART_VERSION}.yaml"

–create-namespace \

helm ls -n loki-stack

Por fim, verifique o status da liberação do Helm:

NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
loki    loki-stack      1               2022-06-08 10:00:06.838665 +0300 EEST   deployed        loki-stack-2.6.4        v2.4.2

A saída se parece com (a coluna STATUS deve exibir ‘implantado’):

kubectl get all -n loki-stack

Em seguida, inspecione todos os recursos do Kubernetes criados para o Loki:

NAME                      READY   STATUS    RESTARTS   AGE
pod/loki-0                1/1     Running   0          44m
pod/loki-promtail-8dskn   1/1     Running   0          44m
pod/loki-promtail-mgb25   1/1     Running   0          44m
pod/loki-promtail-s7cp6   1/1     Running   0          44m

NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
service/loki            ClusterIP   10.245.195.248   <none>        3100/TCP   44m
service/loki-headless   ClusterIP   None             <none>        3100/TCP   44m

NAME                           DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
daemonset.apps/loki-promtail   3         3         3       3            3           <none>          44m

NAME                    READY   AGE
statefulset.apps/loki   1/1     44m

Você deve ter recursos implantados para o próprio Loki (loki-0) e Promtail (loki-promtail). A saída se parece com:

No próximo passo, você irá configurar o Grafana para usar a fonte de dados Loki e visualizar logs de aplicativos.

Passo 2 – Configurar o Grafana com o Loki

kubectl --namespace monitoring port-forward svc/kube-prom-stack-grafana 3000:80

Você NÃO deve expor o Grafana para uma rede pública (por exemplo, criar um mapeamento de ingresso ou serviço de Balanceador de Carga) com login/senha padrão.

1. Em seguida, abra um navegador da web em localhost:3000 e siga as etapas abaixo:
2. Clique na engrenagem de Configuração no painel esquerdo.
3. Selecione Fontes de dados.
4. Clique no botão azul Adicionar fonte de dados.
5. Selecione Loki na lista e adicione a URL do Loki http://loki.loki-stack:3100.

Salve e teste.

Se tudo correr bem, uma mensagem de etiqueta verde aparecerá, dizendo Fonte de dados conectada e etiquetas encontradas.

Agora, você pode acessar logs da guia Explorar do Grafana. Certifique-se de selecionar Loki como fonte de dados. Use o botão Ajuda para o guia de consulta de log.

No próximo passo, você será apresentado ao LogQL, que é semelhante ao PromQL mas para logs. Alguns recursos básicos do LogQL também serão apresentados.

Passo 3 – Usando LogQL

Neste passo, você aprenderá como usar LogQL para consultar logs de aplicativos e aproveitar os recursos disponíveis para facilitar seu trabalho.

A basic LogQL query consists of two parts: the log stream selector and a filter expression. Due to Loki’s design, all LogQL queries are required to contain a log stream selector.

O Loki vem com sua própria linguagem para consultar logs chamada LogQL. O LogQL pode ser considerado um grep distribuído com etiquetas para filtragem.

O seletor de fluxo de log reduzirá o número de fluxos de log para um volume gerenciável. Dependendo de quantas etiquetas você usa para filtrar os fluxos de log, isso afetará o desempenho relativo da execução da consulta. A expressão de filtro é então usada para fazer um grep distribuído sobre os fluxos de log recuperados.

kubectl --namespace monitoring port-forward svc/kube-prom-stack-grafana 3000:80

Primeiro, você precisa expor o console web do Grafana em sua máquina local (credenciais padrão: admin/prom-operator):

{container="vote-bot", namespace="emojivoto"}

A seguir, aponte seu navegador da web para localhost:3000 e navegue até a aba Explorar no painel esquerdo. Selecione Loki no menu da fonte de dados e execute esta consulta:

A saída se parece com o seguinte:

{container="web-svc",namespace="emojivoto"} |= "Error"

Execute outra consulta, mas desta vez filtre os resultados para incluir apenas a mensagem de “Erro”:

A saída se parece com o seguinte. Observe como a palavra “Erro” está sendo destacada no painel de resultados da consulta.

• A log stream selector {container="web-svc", namespace="emojivoto"}, which targets the web-svc container from the ambassador namespace.
• A filter – e.g.: |= "Error", which shows only the lines containing the warning word.

Como você pode ver nos exemplos acima, cada consulta é composta por:

Consultas mais complexas podem ser criadas usando operadores de agregação. Para mais detalhes sobre o tema e outras funcionalidades avançadas, visite a página oficial do LogQL.

Outra característica do Loki que vale a pena mencionar são os Rótulos. Os rótulos permitem que você organize fluxos. Em outras palavras, os rótulos adicionam metadados a um fluxo de logs, para que o sistema possa distingui-lo posteriormente. Essencialmente, são pares chave-valor que podem ser qualquer coisa que você queira, desde que tenham um significado para os dados sendo marcados.

O Loki indexa dados com base em rótulos, permitindo um armazenamento mais eficiente. A imagem a seguir destaca esse recurso no painel de Rótulos de logs:

No próximo passo, você descobrirá o Promtail, que é o agente responsável por buscar e transformar os dados (adicionando rótulos, adicionando novos campos, descartando, etc).

Passo 4 – Compreensão do Promtail

Neste passo, você aprenderá o que é o Promtail e como ele funciona. Ele é implantado como um DaemonSet, e é uma parte importante da instalação da sua pilha Loki, responsável por buscar todos os logs dos Pods em execução no seu cluster Kubernetes.

• O que o Promtail essencialmente faz é:
• Descobrir alvos que emitem logs.
• Anexar rótulos aos fluxos de logs.

Enviar fluxos de logs para a instância Loki.

Descoberta e Análise de Logs

Antes que o Promtail possa enviar quaisquer dados de arquivos de log para o Loki, ele precisa descobrir informações sobre seu ambiente. Isso significa descobrir aplicativos que emitem linhas de log para arquivos que precisam ser monitorados.

O Promtail utiliza o mesmo mecanismo de descoberta de serviço do Prometheus, embora atualmente suporte apenas a descoberta de serviço Estático e Kubernetes. Essa limitação ocorre porque o Promtail é implantado como um daemon em cada máquina local e não descobre rótulos de outras máquinas. A descoberta de serviço do Kubernetes busca os rótulos necessários no servidor de API do Kubernetes, enquanto o Estático geralmente cobre todos os outros casos de uso.

kubectl get ds -n loki-stack

Assim como em todo agente de monitoramento, é necessário ter uma maneira de mantê-lo funcionando o tempo todo. A implantação do Helm do conjunto Loki stack já torna isso possível por meio de um DaemonSet, como visto abaixo:

NAME                                       DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
kube-prom-stack-prometheus-node-exporter   2         2         2       2            2           <none>          7d4h
loki-promtail                              2         2         2       2            2           <none>          5h6m

A saída se parece com o seguinte (observe a linha loki-promtail):

kubectl get cm loki-stack -n loki-stack -o yaml > loki-promtail-config.yaml

A seção scrape_configs da configuração principal do Promtail mostrará os detalhes de como o Promtail descobre os pods do Kubernetes e atribui rótulos a eles. Você pode usar o kubectl para inspeção (observe que a configuração da aplicação é armazenada usando um ConfigMap do Kubernetes):

code loki-promtail-config.yaml

Em seguida, abra o arquivo loki-promtail-config.yaml usando um editor de texto de sua escolha (preferencialmente com suporte YAML).

...
scrape_configs:
  - job_name: kubernetes-pods-name
    pipeline_stages:
      - docker: {}
    kubernetes_sd_configs:
    - role: pod
    relabel_configs:
    - action: replace
      source_labels:
      - __meta_kubernetes_namespace
      target_label: namespace
...

Depois, procure a seção scrape_configs. A saída deve ser semelhante a:

O Promtail sabe como raspar logs usando scrape_configs. Cada configuração de raspagem diz ao Promtail como descobrir logs e extrair rótulos. Em seguida, cada configuração de raspagem contém uma ou mais entradas (chamadas de jobs) que são executadas para cada destino descoberto. Então, cada job pode conter um pipeline composto por várias etapas. O objetivo principal de cada estágio é transformar os logs da sua aplicação, mas também pode descartar (filtrar) dados de log indesejados, se necessário. Os jobs podem conter também estrofes relabel_configs que são usadas para transformar rótulos.

• Explicações para a configuração acima:
• job_name: Define um novo job e seu nome associado.
• pipeline_stages: Pode ser usado para adicionar ou atualizar rótulos, corrigir o carimbo de data/hora ou reescrever completamente linhas de log. Ele usa estágios para realizar as tarefas mencionadas anteriormente. O trecho de configuração apresentado acima utiliza um estágio docker, que pode extrair dados com base no formato padrão do Docker. Você pode consultar a documentação oficial para ler mais sobre Estágios e Pipelines.
• kubernetes_sd_config: Informa ao Promtail como descobrir logs provenientes de Pods via descoberta de serviço do Kubernetes.

relabel_configs: Define uma lista de operações para transformar os rótulos da descoberta em outra forma. O trecho de configuração apresentado acima está renomeando o rótulo de origem __meta_kubernetes_namespace fornecido pelo mecanismo de descoberta de serviço do Kubernetes para uma forma mais amigável: namespace.

Descartando Logs por Namespace

Na maioria dos casos, você pode não querer buscar logs de todos os namespaces (e pods, implicitamente). Isso é muito útil para evitar tráfego elevado dentro do seu cluster Kubernetes causado pelo Promtail, assim como para reduzir a quantidade de dados ingeridos pelo Loki. O que o Promtail permite fazer nesse caso é descartar logs de namespaces indesejados e manter o restante. Outra vantagem dessa abordagem é que o volume de dados que precisa ser indexado pelo Loki é reduzido, o que significa menos armazenamento utilizado e número de objetos, se estiver utilizando um bucket do DO Spaces, por exemplo.

O Promtail permite filtrar logs com base no namespace, através do estágio drop. Você pode usar o Helm para configurar o Promtail para filtragem por namespace.

code 04-setup-observability/assets/manifests/loki-stack-values-v2.6.4.yaml

Primeiramente, abra o arquivo 04-setup-observability/assets/manifests/loki-stack-values-v2.6.4.yaml fornecido no repositório do Starter Kit, usando um editor de texto de sua escolha (preferencialmente com suporte a lint YAML). Certifique-se de alterar o diretório onde o repositório do Starter Kit foi clonado primeiro.

promtail:
  enabled: true
  Em seguida, remova os comentários que rodeiam a seção pipelineStages. No exemplo a seguir, você configurará o Promtail para descartar todos os logs provenientes de todos os namespaces prefixados com kube- como kube-node-lease, kube-public, kube-system. A saída se parece com:
  #
  # Habilitar monitoramento de serviço do Promtail
  # serviceMonitor:
  #   enabled: true
  #
  pipelineStages:
    - docker: {}
    - drop:
        source: namespace
        expression: "kube-.*"

# Estágios de pipeline definidos pelo usuário

• Explicações para a configuração acima:
• pipelineStages: Indica ao Helm para inserir estágios de pipeline definidos pelo usuário em cada trabalho que ele cria. Por padrão, o gráfico Helm do stack do Loki está configurando o Promtail para buscar todos os logs provenientes de todos os namespaces e pods (você pode inspecionar o modelo ConfigMap para detalhes).
• docker: Indica ao Promtail para usar um estágio Docker. Ajuda com a formatação dos logs do Docker.

drop: Indica ao Promtail para usar um estágio Drop. Em seguida, você faz uso do campo source, para descartar logs com base em um namespace. Por fim, expression é o seletor regex para o campo source.

HELM_CHART_VERSION="2.6.4"

helm upgrade loki grafana/loki-stack --version "${HELM_CHART_VERSION}" \
  --namespace=loki-stack \
  -f "04-setup-observability/assets/manifests/loki-stack-values-v${HELM_CHART_VERSION}.yaml"

Por fim, salve o arquivo de valores e aplique as alterações usando helm upgrade:

Se a atualização foi bem-sucedida e nenhum erro foi relatado, você pode verificar o LogQL se os logs ainda estão sendo enviados para o Loki do namespace kube-system. Aguarde cerca de um minuto e, em seguida, execute as seguintes consultas. Certifique-se de ajustar a janela de tempo no Grafana também para corresponder ao intervalo do último minuto (você precisa buscar apenas os dados mais recentes).

kubectl --namespace monitoring port-forward svc/kube-prom-stack-grafana 3000:80

Em seguida, crie um encaminhamento de porta para o console web do Grafana em sua máquina local. As credenciais padrão são admin/prom-operator.

{namespace="kube-system"}

{namespace="kube-public"}

{namespace="kube-node-leases"}

Acesse seu navegador da web em localhost:3000, e navegue até a guia Explore no painel esquerdo. Selecione Loki no menu de fontes de dados e execute as seguintes consultas:

Então, você pode instalar o painel Loki&Promtail Grafana fornecido pela comunidade e inspecionar o volume de dados ingestados pelo Loki. Após um tempo, você pode obter feedback visual sobre o que significa filtrar logs de aplicativos desnecessários, conforme visto na imagem abaixo (antes da filtragem, no lado esquerdo, e depois, no lado direito):

Para mais recursos e explicações detalhadas, por favor, visite a documentação oficial do Promtail.

No próximo passo, você aprenderá como configurar armazenamento persistente para o Loki usando DO Spaces.

Passo 5 – Configurando Armazenamento Persistente para o Loki

Nesta etapa, você aprenderá como habilitar armazenamento persistente para o Loki. Você usará o bucket DO Spaces criado na seção Pré-requisitos do tutorial.

Por padrão, o Helm implanta o Loki com armazenamento efêmero usando o volume emptyDir. Isso significa que todos os seus dados de log indexados serão perdidos se ele reiniciar ou se o cluster DOKS for recriado. Para preservar os dados de log indexados através de reinicializações do Pod, o Loki pode ser configurado para usar DO Spaces em vez disso.

DO Spaces escala muito bem e é mais barato do que PVs que dependem de Armazenamento de Bloco. Por outro lado, você não precisa se preocupar em ficar sem espaço em disco. Além disso, você não precisa se preocupar com o dimensionamento de PVs e fazer cálculos extras.

cd Kubernetes-Starter-Kit-Developers

Primeiro, altere o diretório onde o repositório Starter Kit foi clonado:

code 04-setup-observability/assets/manifests/loki-stack-values-v2.6.4.yaml

Em seguida, abra o arquivo loki-stack-values-v2.6.4.yaml fornecido no repositório Starter Kit usando um editor de texto de sua escolha (preferencialmente com suporte a lint YAML).

loki:
  enabled: true
  config:
    schema_config:
      configs:
        - from: '2020-10-24'
          store: boltdb-shipper
          object_store: aws
          schema: v11
          index:
            prefix: index_
            period: 24h
    storage_config:
      boltdb_shipper:
        active_index_directory: /data/loki/boltdb-shipper-active
        cache_location: /data/loki/boltdb-shipper-cache
        cache_ttl: 24h
        shared_store: aws
      aws:
        bucketnames: <YOUR_DO_SPACES_BUCKET_NAME_HERE>
        endpoint: <YOUR_DO_SPACES_BUCKET_ENDPOINT_HERE>
        region: <YOUR_DO_SPACES_BUCKET_REGION_HERE>
        access_key_id: <YOUR_DO_SPACES_ACCESS_KEY_HERE>
        secret_access_key: <YOURDO_SPACES_SECRET_KEY_HERE>
        s3forcepathstyle: true

Remova os comentários que cercam as chaves schema_config e storage_config. A configuração final de armazenamento do Loki se parece com o seguinte. (Substitua os espaços reservados <> conforme necessário).

• Explicação para a configuração acima:
• schema_config – define um tipo de armazenamento e uma versão de esquema para facilitar migrações. Os esquemas podem diferir com base nas instalações do Loki, então certifique-se de que o esquema permaneça consistente ao longo da configuração. Neste caso, boltdb-shipper é especificado como a implementação de armazenamento e uma versão de esquema v11. O período de 24h para o índice é o valor padrão e preferido, então por favor não o altere. Visite Configurações de Esquema para mais detalhes.

storage_config – informa ao Loki sobre detalhes de configuração de armazenamento, como definir parâmetros do BoltDB Shipper. Ele também informa ao Loki sobre os parâmetros de armazenamento aws compatíveis com S3 (nome do bucket, credenciais, região, etc).

HELM_CHART_VERSION="2.6.4"

helm upgrade loki grafana/loki-stack --version "${HELM_CHART_VERSION}" \
  --namespace=loki-stack \
  -f "04-setup-observability/assets/manifests/loki-stack-values-v${HELM_CHART_VERSION}.yaml"

Aplicar configurações, usando helm:

kubectl get pods -n loki-stack -l app=loki

Agora, verifique se o pod principal da aplicação Loki está em execução. Pode levar até 1 minuto ou mais para iniciar.

NAME     READY   STATUS    RESTARTS   AGE
loki-0   1/1     Running   0          13m

Você também pode verificar os logs enquanto espera. Também é uma boa prática em geral verificar os logs da aplicação e ver se algo está errado ou não.

Se tudo correr bem, você deverá ver o bucket DO Spaces contendo as pastas index e chunks (fake).

Para opções mais avançadas e ajuste fino do armazenamento para o Loki, por favor, visite a documentação oficial de armazenamento do Loki.

Em seguida, você aprenderá como definir políticas de retenção de armazenamento para o Loki.

Passo 6 – Definindo a Retenção de Armazenamento do Loki

Nesta etapa, você aprenderá como definir as políticas de retenção do DO Spaces. Como você configurou o DO Spaces como o backend de armazenamento padrão para o Loki, as mesmas regras se aplicam a cada tipo de armazenamento compatível com S3.

O S3 é altamente escalável, então você não precisa se preocupar com problemas de espaço em disco. Mas ainda é uma boa prática ter uma política de retenção em vigor. Dessa forma, dados muito antigos podem ser excluídos se não forem necessários.

S3CMD é uma ferramenta realmente útil para inspecionar quantos objetos estão presentes, assim como o tamanho do bucket DO Spaces usado para a retenção do Loki. S3CMD também ajuda a verificar se as políticas de retenção definidas até o momento estão funcionando ou não. Por favor, siga o guia da DigitalOcean para instalar e configurar o s3cmd.

<LifecycleConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Rule>
    <ID>Expire old fake data</ID>
    <Prefix>fake/</Prefix>
    <Status>Enabled</Status>
    <Expiration>
      <Days>10</Days>
    </Expiration>
  </Rule>

  <Rule>
    <ID>Expire old index data</ID>
    <Prefix>index/</Prefix>
    <Status>Enabled</Status>
    <Expiration>
      <Days>10</Days>
    </Expiration>
  </Rule>
</LifecycleConfiguration>

Definir o ciclo de vida para o bucket de armazenamento do Loki é alcançado via utilitário s3cmd. Você vai usar o arquivo de configuração loki_do_spaces_lifecycle.xml fornecido no repositório Git do Starter Kit para configurar a retenção para o bucket do Loki. O conteúdo do arquivo de política se parece com:

A configuração de ciclo de vida acima removerá automaticamente todos os objetos dos caminhos fake/ e index/ no armazenamento do Loki após 10 dias. Um período de 10 dias é escolhido neste exemplo porque geralmente é suficiente para fins de desenvolvimento. Para produção ou outros sistemas críticos, é recomendado um período de >= 30 dias.

cd Kubernetes-Starter-Kit-Developers

Primeiro, altere o diretório onde o repositório do Starter Kit foi clonado.

Em seguida, abra e inspecione o arquivo 04-setup-observability/assets/manifests/loki_do_spaces_lifecycle.xml do repositório do Starter Kit, usando um editor de texto de sua escolha (preferencialmente com suporte a lint XML), e ajuste conforme suas necessidades.

s3cmd setlifecycle 04-setup-observability/assets/manifests/loki_do_spaces_lifecycle.xml s3://<LOKI_STORAGE_BUCKET_NAME>

Defina a política de ciclo de vida substituindo os espaços reservados <> conforme necessário.

s3cmd getlifecycle s3://<LOKI_STORAGE_BUCKET_NAME>

Por fim, verifique se a política foi definida:

s3cmd du -H s3://<LOKI_DO_SPACES_BUCKET_NAME>

Após concluir as etapas acima, você pode inspecionar o tamanho do bucket e o número de objetos via subcomando du do s3cmd (o nome é emprestado do utilitário Linux Disk Usage). Substitua os espaços reservados <> conforme necessário:

19M    2799 objects s3://loki-storage-test/

A saída se parece com o seguinte (observe que ele imprime o tamanho do bucket – 19M – e o número de objetos presentes – 2799):

Em seguida, a implementação de backend do DO Spaces limpará os objetos automaticamente com base na data de expiração. Você sempre pode voltar e editar a política, se necessário, posteriormente, enviando uma nova.

Conclusão

Neste tutorial, você aprendeu como instalar o Loki para monitoramento de logs em seu cluster DOKS. Em seguida, você configurou o Grafana para usar o Loki como fonte de dados. Você também aprendeu sobre o LogQL para consultar logs e como configurar armazenamento persistente e retenção para o Loki.

• Saiba Mais
• Monitoramento de Logs do Kubernetes usando Grafana Loki e DigitalOcean Spaces
• Melhores Práticas no Monitoramento de um Cluster Kubernetes com Prometheus, Grafana e Loki

Configurar Monitoramento de Cluster DOKS com Helm e Prometheus Operator