Controlador de entrada F5 NGINX com operador Prometheus para métricas prontas para uso

O NGINX Ingress Controller da F5 NGINX combinado com o operador Prometheus ServiceMonitor CRD torna a coleta de métricas de implantações do NGINX Ingress Controller muito mais fácil e rápida usando o Helm. O gráfico do helm do NGINX Ingress Controller agora oferece suporte à capacidade de aproveitar imediatamente sua infraestrutura existente do Prometheus e do prometheus-operator, permitindo que você implante o NIC e tenha métricas prontas para uso, aproveitando o Prometheus ServiceMonitor . Este artigo explica o que é o ServiceMonitor , como instalá-lo e como usar o gráfico do Helm do NGINX Ingress Controller para definir essas configurações específicas.

Monitor de serviço Prometheus

A definição de recurso personalizado (CRD) do Prometheus ServiceMonitor permite que você defina declarativamente como um conjunto dinâmico de serviços deve ser monitorado. Os serviços monitorados são definidos usando seletores de rótulos do Kubernetes. Isso permite que uma organização introduza convenções que regem como as métricas são expostas. Seguindo essas convenções, novos serviços são descobertos automaticamente, e o Prometheus começa a coletar métricas sem a necessidade de reconfigurar o sistema. O ServiceMonitor faz parte do Prometheus Operator. Esses recursos descrevem e gerenciam alvos de monitoramento a serem coletados pelo Prometheus. O recurso Prometheus se conecta ao ServiceMonitor usando um campo Seletor do ServiceMonitor . O Prometheus pode identificar facilmente quais alvos foram marcados para scraping. Isso lhe dá mais controle e flexibilidade para aproveitar os recursos do ServiceMonitor no seu cluster Kubernetes para monitorar soluções como o NGINX Ingress Controller. Para facilitar as coisas e fornecer métricas prontas para uso para o NGINX Ingress Controller, adicionamos recentemente a capacidade de usar o Prometheus ServiceMonitor ao nosso gráfico do Helm. Isso torna muito fácil habilitar métricas para que o Prometheus comece a extrair dados logo após a implantação do NGINX Ingress Controller. Para usar esse recurso, precisamos adicionar um segundo serviço criado especificamente para coleta de métricas ao qual o ServiceMonitor irá “anexar”. Isso informará ao operador do Prometheus qual serviço ele deve monitorar (usando os rótulos nos metadados) para que ele saiba o que e onde coletar. Exemplo de como seria um serviço para o NGINX Ingress Controller se fizesse parte de arquivos de implantação ou helm:

apiVersion: v1
kind: Service
metadata:
  name: nginx-ingress-servicemonitor
  labels:
    app: nginx-ingress-servicemonitor
spec:
  ports:
  - name: prometheus
    protocol: TCP
    port: 9113
    targetPort: 9113
  selector:
    app: nginx-ingress

O acima fará parte da implantação. O rótulo, app: nginx-ingress-servicemonitor “conecta” ao serviceMonitor para coleta de métricas do Prometheus. Abaixo está um exemplo de serviceMonitor que se vincularia ao serviço acima chamado nginx-ingress-servicemonitor :

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: nginx-ingress-servicemonitor
  labels:
    app: nginx-ingress-servicemonitor
spec:
  selector:
    matchLabels:
      app: nginx-ingress-servicemonitor
  endpoints:
  - port: prometheus

É necessário criar um recurso do Prometheus, que seja configurado para procurar os recursos do serviceMonitor , permitindo que o Prometheus saiba de forma rápida e fácil quais endpoints coletar métricas. No nosso exemplo abaixo, este recurso informa ao Prometheus quais itens monitorar de acordo com a especificação. Abaixo, estamos monitorando spec.serviceMonitorSelector.matchLabels: . Podemos ver que o Prometheus está procurando matchLabels com app.nginx-ingress-servicemonitor em qualquer namespace. Isso corresponde ao recurso serviceMonitor que será implantado pelos gráficos do Helm do NGINX Ingress Controller e pelo Helm.

apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: prometheus
  labels:
    prometheus: prometheus
spec:
  replicas: 1
  serviceAccountName: prometheus
  serviceMonitorNamespaceSelector:  {}
  serviceMonitorSelector:
    matchLabels:
      app: nginx-ingress-servicemonitor
  resources:
    requests:
      memory: 500Mi

Aqui está um diagrama que conecta as diferentes peças: Figura 1: relacionamento objeto serviço-monitor

Instalando Prometheus, prometheus-operator e Grafana

Usaremos o prometheus-community/kube-prometheus-stack para instalar a implantação completa. Isso instalará o prometheus, o prometheus-operator e o Grafana. Também vamos especificar que queremos instalar isso no namespace de monitoramento para isolamento. Veja como podemos instalar com o helm: helm install metrics01 prometheus-community/kube-prometheus-stack -n monitoring --create-namespace

Crie e instale o recurso Prometheus

Depois que o Prometheus e os CRDs do Prometheus estiverem instalados no cluster, podemos criar nosso recurso Prometheus. Ao implementar isso com antecedência, podemos “pré-analisar” nossa configuração do Prometheus com os rótulos que usaremos no gráfico do leme. Com essa abordagem, podemos fazer com que o Prometheus comece automaticamente a procurar pelo NGINX Ingress Controller e a coletar métricas. Nosso recurso Prometheus será implantado antes da instalação do NGINX Ingress Controller. Isso permitirá que o operador prometheus pegue e extraia automaticamente nosso controlador NGINX Ingress após a implantação, fornecendo métricas rapidamente.

apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: prometheus
  namespace: default
  labels:
    prometheus: monitoring
spec:
  replicas: 1
  serviceAccountName: prometheus
  serviceMonitorNamespaceSelector:  {}
  serviceMonitorSelector:
    matchLabels:
      app: nginx-ingress-servicemonitor
  resources:
    requests:
      memory: 500Mi

Nosso exemplo acima é um exemplo básico. A parte principal é o valor spec.serviceMonitorSelector.matchLabels que especificamos. Esse valor é o que usaremos quando implantarmos o controlador NGINX Ingress com o gráfico Helm. Queremos fornecer métricas do Prometheus prontas para uso. Para fazer isso, usaremos o gráfico do leme do NGINX Ingress Controller.

Alterações no helm values.yaml do controlador de entrada NGINX

Podemos revisar o arquivo values.yaml para o gráfico do leme. Há uma seção do Prometheus na qual queremos nos concentrar, pois ela contém as peças necessárias para habilitar o Prometheus, criar o serviço necessário e criar um recurso serviceMonitor . Na seção Prometheus, devemos ver várias configurações: prometheus.service prometheus.serviceMonitor Vamos habilitar ambas as configurações acima para gerar o serviço necessário e o serviceMonitor ao usar o gráfico do leme. Aqui está a seção específica onde habilitamos o serviço, habilitamos o serviceMonitor e definimos os rótulos na seção serviceMonitor :

`servicemonitor` support was recently added to the NGINX Ingress controller helm chart. 
prometheus:
  ## Expose NGINX or NGINX Plus metrics in the Prometheus format.
  create: true

  ## Configures the port to scrape the metrics.
  port: 9113

  secret: ""

  ## Configures the HTTP scheme used.
  scheme: http

  service:
    ## Requires prometheus.create=true
    create: true

  serviceMonitor:
    create: true
    labels: { app: nginx-ingress-servicemonitor } 

Separando os valores acima:

prometheus:
  ## Expose NGINX or NGINX Plus metrics in the Prometheus format.
  create: true

Informa ao Helm que você deseja habilitar o ponto de extremidade do NIC Prometheus. Você também pode definir uma porta, um esquema e um segredo, se necessário. Ao definir o valor de prometheus.service.create como true, o Helm criará automaticamente o serviço NIC ServiceMonitor.

service:
    ## Creates a ClusterIP Service to expose Prometheus metrics internally
    ## Requires prometheus.create=true
    create: true

Por fim, precisamos criar o serviceMonitor . Definir isso como verdadeiro e adicionar os rótulos corretos criará e adicionará os rótulos que correspondem ao nosso recurso Prometheus.

serviceMonitor:
    ## Creates a serviceMonitor to expose statistics on the kubernetes pods.
    create: true
    ## Kubernetes object labels to attach to the serviceMonitor object.
    labels: { app: nginx-ingress-servicemonitor } 

O rótulo remete ao nome do serviço.labels: { app: nginx-ingress-servicemointor } Para resumir. Habilite o Prometheus, isso expõe a capacidade do exportador Prometheus do NIC. Defina um objeto Service, é assim que o Prometheus ServiceMonitor descobre os endpoints do exportador Prometheus do NIC. Defina um objeto serviceMonitor. Isso informa ao Prometheus ServiceMonitor para monitorar essa coisa.

Agora podemos instalar o NGINX Ingress Controller com o helm .

Depois de modificar nosso values.yaml , podemos prosseguir com a instalação do controlador NGINX Ingress. helm install nic01 -n nginx-ingress --create-namespace -f values.yaml . Depois de implantar o NGINX Ingress Controller, podemos abrir o painel do Prometheus e navegar até o menu de status. De lá, podemos navegar até os destinos e visualizações de descoberta de serviços. Assim que o Prometheus localizar nosso novo recurso ServiceMonitor, ele começará a analisar o endpoint e coletar métricas que serão imediatamente coletadas no painel do Prometheus.

Figura 2: Descoberta do serviço Prometheus

Figura 3: Alvo de Prometeu

Figura 4: Consulta NGINX do Prometheus

Podemos ver que, usando ferramentas nativas do Kubernetes, como helm e Prometheus, o NGINX Ingress Controller pode tornar a coleta de métricas no início da implantação muito mais fácil, fornecendo "métricas prontas para uso". Aqui estão os documentos de referência para instalar o prometheus-operator : https://prometheus-operator.dev/ https://github.com/prometheus-operator/prometheus-operator