VictoriaMetrics Operator

O VictoriaMetrics Operator é um operador para Kubernetes que automatiza a implantação e o gerenciamento de componentes de monitoramento baseados no VictoriaMetrics. Ele permite criar e configurar serviços individuais para coleta, armazenamento e visualização de métricas.

O operador utiliza CRDs (Custom Resource Definitions) para gerenciar a infraestrutura de monitoramento. Os principais componentes incluem:

• VMSingle — instância única do VictoriaMetrics responsável por armazenar métricas. Indicado para projetos simples e clusters com baixo tráfego
• VMCluster — configuração escalável com réplicas de armazenamento e componentes de proxy. Ideal para produção e ambientes com alto volume
• VMAgent — coleta métricas de pods, services e outras fontes, enviando-as para VMSingle ou VMCluster via remoteWrite
• VMPodScrape — objeto CRD que define quais pods devem ter métricas coletadas e em quais endereços/portas

A documentação completa do VictoriaMetrics Operator está disponível no site oficial do projeto.

Instalar

Para instalar o VictoriaMetrics Operator:

1. Acesse a seção Kubernetes e clique no cluster
2. Na aba Complementos, clique em VictoriaMetrics Operator
3. Na janela de configuração, você pode opcionalmente ajustar parâmetros, como definir um namespace personalizado, alterar versões dos componentes ou desativar CRDs desnecessários
4. Clique em Instalar

Após a instalação, o cluster incluirá o namespace victoria-metrics-operator e todos os CRDs necessários, incluindo VMSingle, VMAgent, VMPodScrape e outros.

Para listá-los:

kubectl get crd | grep 'vm'

Exemplo de uso

Neste exemplo, você irá:

1. Implantar uma instância VMSingle para armazenar métricas
2. Configurar um VMAgent para coletar métricas
3. Iniciar um pod com Nginx e nginx-prometheus-exporter para expor métricas
4. Criar um objeto VMPodScrape para permitir que o VMAgent colete essas métricas
5. Configurar um Ingress para acessar a interface web do VictoriaMetrics

Você precisará ter o addon Nginx Ingress instalado no cluster para este exemplo.

Passo 1: Criar VMSingle

Este componente receberá e armazenará as métricas. No exemplo, ele está configurado com requisitos mínimos de recursos e armazena dados em memória por 1 dia.

Crie um arquivo chamado vmsingle.yaml com a seguinte configuração:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMSingle
metadata:
  name: vm-single
  namespace: victoria-metrics-operator
spec:
  retentionPeriod: "1"
  resources:
    requests:
      cpu: 100m
      memory: 256Mi

Passo 2: Criar VMAgent

Este agente coletará métricas e as enviará para o VMSingle. Crie um arquivo chamado vmagent.yaml:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMAgent
metadata:
  name: vmagent
  namespace: victoria-metrics-operator
spec:
  remoteWrite:
    - url: http://vmsingle-vm-single.victoria-metrics-operator:8428/api/v1/write
  scrapeInterval: 30s
  selectAllByDefault: true
  port: "8429"

Passo 3: Implantar Nginx e exporter

Inicie um pod com Nginx e nginx-prometheus-exporter, que exporá métricas em /stub_status.

Crie um arquivo chamado nginx.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: victoria-metrics-operator
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
              name: http
          volumeMounts:
            - name: nginx-conf
              mountPath: /etc/nginx/conf.d/default.conf
              subPath: default.conf
        - name: exporter
          image: nginx/nginx-prometheus-exporter:1.1.0
          args:
            - "-nginx.scrape-uri=http://localhost/stub_status"
          ports:
            - containerPort: 9113
              name: metrics
      volumes:
        - name: nginx-conf
          configMap:
            name: nginx-conf
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-conf
  namespace: victoria-metrics-operator
data:
  default.conf: | server { listen 80; location / { return 200 'OK'; } location /stub_status { stub_status; allow 127.0.0.1; deny all; } } ---
apiVersion: v1
kind: Service
metadata:
  name: nginx
  namespace: victoria-metrics-operator
spec:
  selector:
    app: nginx
  ports:
    - name: http
      port: 80
      targetPort: http
    - name: metrics
      port: 9113
      targetPort: metrics

Passo 4: Configurar VMPodScrape

Este objeto informa ao VMAgent de quais pods coletar métricas. Ele irá direcionar pods com o rótulo app: nginx e consultar a porta de metrics em /metrics.

Crie um arquivo chamado vmpodscrape.yaml:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMPodScrape
metadata:
  name: nginx-scrape
  namespace: victoria-metrics-operator
spec:
  selector:
    matchLabels:
      app: nginx
  podMetricsEndpoints:
    - port: metrics
      path: /metrics
      interval: 30s

Passo 5: Configurar Ingress para a interface

Antes de configurar o Ingress, verifique se o cluster possui um service do tipo LoadBalancer para acesso externo:

kubectl get svc -n ingress-nginx

Se não houver, crie:

apiVersion: v1
kind: Service
metadata:
  name: nginx-loadbalancer
  namespace: ingress-nginx
spec:
  selector:
    app.kubernetes.io/name: ingress-nginx
  ports:
    - port: 80
      targetPort: 80
      appProtocol: k8s.hostman.com/proto-http
  type: LoadBalancer

Após a criação, obtenha o IP externo:

kubectl get svc -n ingress-nginx nginx-loadbalancer

Use esse IP como registro A do domínio onde a interface do VictoriaMetrics ficará acessível.

Passo 6: Criar Ingress para a interface do VictoriaMetrics

Especifique o domínio no campo host do manifesto do Ingress. Crie um arquivo chamado vm-ui-ingress.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-loadbalancer
  namespace: ingress-nginx
spec:
  selector:
    app.kubernetes.io/name: ingress-nginx
  ports:
    - port: 80
      targetPort: 80
      appProtocol: k8s.hostman.com/proto-http
  type: LoadBalancer

Aplique todos os manifestos criados:

kubectl apply -f vmsingle.yaml
kubectl apply -f vmagent.yaml
kubectl apply -f nginx.yaml
kubectl apply -f vmpodscrape.yaml
kubectl apply -f vm-ui-ingress.yaml

Acessar a interface

Abra o domínio especificado no seu Ingress (por exemplo, http://vm.example.com).

Uma vez lá:

1. Selecione vmui para abrir a interface web do VictoriaMetrics
2. No campo query, digite o nome de uma métrica, como up, e clique em Execute Query

Se tudo estiver configurado corretamente, você verá as métricas sendo coletadas do pod do Nginx.

Viewing metrics in the VictoriaMetrics interface