F5 NGINX Ingress Controller com Prometheus-operator para métricas prontas para uso

Jason WilliamsGerente Principal de Produto | F5

NGINX Ingress Controller da F5 NGINX combinado com o operador Prometheus ServiceMonitor CRD torna a coleta de métricas das implantações do NGINX Ingress Controller muito mais fácil e rápida usando o Helm. O chart do Helm do NGINX Ingress Controller agora permite aproveitar imediatamente sua infraestrutura existente do Prometheus e do prometheus-operator, possibilitando implantar o NIC e obter métricas prontas para uso por meio do Prometheus ServiceMonitor. Este artigo explica o que é o ServiceMonitor, como instalá-lo e como usar o chart do Helm do NGINX Ingress Controller para definir essas configurações específicas.

ServiceMonitor do Prometheus

A definição de recurso personalizado (CRD) Prometheus ServiceMonitor permite definir 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 estabeleça convenções que determinem como as métricas são expostas. Ao seguir 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. ServiceMonitor faz parte do Prometheus Operator. Esses recursos descrevem e gerenciam os alvos de monitoramento dos quais o Prometheus deve coletar dados. O recurso Prometheus se conecta ao ServiceMonitor usando um campo ServiceMonitor Selector. O Prometheus pode identificar facilmente quais alvos foram marcados para coleta. Isso oferece mais controle e flexibilidade para aproveitar os recursos ServiceMonitor no seu cluster Kubernetes para monitorar soluções como o NGINX Ingress Controller. Para facilitar o processo e fornecer métricas prontas para uso do NGINX Ingress Controller, adicionamos recentemente ao nosso chart do Helm a possibilidade de usar o Prometheus ServiceMonitor. Isso facilita bastante a ativação de métricas para que o Prometheus comece a coletá-las logo após a implantação do NGINX Ingress Controller. Para usar esse recurso, precisamos adicionar um segundo serviço, criado especificamente para a coleta de métricas, ao qual o ServiceMonitor será “associado”. Isso informará ao Prometheus Operator qual serviço ele deve monitorar (usando os rótulos nos metadados), para que saiba o que coletar e onde fazê-lo. Veja um exemplo de como seria um serviço para o NGINX Ingress Controller se ele fizesse parte dos arquivos de implantação ou do 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 conteúdo acima fará parte da implantação. O rótulo app: nginx-ingress-servicemonitor “conecta-se” ao serviceMonitor para a coleta de métricas pelo Prometheus. Abaixo está um exemplo de serviceMonitor que seria vinculado 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 configurado para procurar os recursos serviceMonitor, permitindo que o Prometheus saiba, de forma rápida e fácil, de quais endpoints coletar métricas. No exemplo abaixo, esse recurso informa ao Prometheus quais itens monitorar na especificação. Abaixo, estamos monitorando spec.serviceMonitorSelector.matchLabels:. Podemos ver que o Prometheus procura matchLabels com app.nginx-ingress-servicemonitor em qualquer namespace. Isso corresponde ao recurso serviceMonitor que será implantado pelos charts 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 os diferentes componentes:

Instalando o Prometheus, o prometheus-operator e o Grafana

Vamos usar 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 fazer a instalação no namespace de monitoramento para garantir o isolamento. Veja como podemos instalar com o helm: helm install metrics01 prometheus-community/kube-prometheus-stack -n monitoring --create-namespace

Criar e instalar o recurso do Prometheus

Depois que o Prometheus e as CRDs do Prometheus forem instalados no cluster, poderemos criar nosso recurso do Prometheus. Ao implantá-lo antecipadamente, podemos “pré-configurar” o Prometheus com os rótulos que usaremos no chart do Helm. Com essa abordagem, podemos fazer com que o Prometheus comece automaticamente a procurar o NGINX Ingress Controller e a coletar métricas. Nosso recurso do Prometheus será implantado antes da instalação do NGINX Ingress Controller. Isso permitirá que o prometheus-operator detecte automaticamente nosso NGINX Ingress Controller após a implantação e colete suas métricas, disponibilizando-as 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 é básico. A parte principal é o valor spec.serviceMonitorSelector.matchLabels que especificamos. Esse valor será usado quando implantarmos o NGINX Ingress Controller com o chart do Helm. Queremos disponibilizar métricas do Prometheus prontas para uso. Para isso, usaremos o chart do Helm do NGINX Ingress Controller.

Alterações no helm do NGINX Ingress Controller em values.yaml changes

Podemos analisar o arquivo values.yaml do chart Helm. Há uma seção do Prometheus na qual queremos nos concentrar, pois ela contém os elementos necessários para habilitar o Prometheus, criar o serviço necessário e criar um recurso serviceMonitor. Na seção do Prometheus, devemos encontrar várias configurações: prometheus.service prometheus.serviceMonitor Vamos habilitar as duas configurações acima para gerar o serviço e o serviceMonitor necessários ao usar o chart Helm. Esta é a seção específica em que habilitamos o serviço e o serviceMonitor, além de definirmos 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 endpoint do Prometheus do NIC. Se necessário, você também pode definir uma porta, um esquema e um segredo. Ao definir o valor de prometheus.service.create como true, o Helm criará automaticamente o serviço ServiceMonitor do NIC.

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

Por fim, precisamos criar o serviceMonitor. Definir essa opção como true e adicionar os rótulos corretos criará e adicionará os rótulos correspondentes ao nosso recurso do 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 faz referência ao nome em service.labels: { app: nginx-ingress-servicemointor } Em resumo: habilite o Prometheus para expor a funcionalidade de exportação de métricas do Prometheus do NIC. Defina um objeto Service; é assim que o ServiceMonitor do Prometheus descobre os endpoints do exportador do Prometheus do NIC. Defina um objeto serviceMonitor. Isso instrui o ServiceMonitor do Prometheus a monitorar esse recurso.

Agora podemos instalar o NGINX Ingress Controller com o helm.

Depois de modificarmos nosso arquivo values.yaml, podemos prosseguir com a instalação do NGINX Ingress Controller. helm install nic01 -n nginx-ingress --create-namespace -f values.yaml . Após implantarmos o NGINX Ingress Controller, podemos abrir o painel do Prometheus e acessar o menu de status. Nele, podemos acessar as visualizações de alvos e descoberta de serviços. Assim que o Prometheus localizar nosso novo recurso ServiceMonitor, ele começará a coletar dados do endpoint e métricas, que serão exibidas imediatamente no painel do Prometheus.

Figura 3: destino do Prometheus

Podemos ver que, ao usar ferramentas nativas do Kubernetes, como o Helm e o Prometheus, o NGINX Ingress Controller pode facilitar muito a coleta de métricas desde o início da implantação, fornecendo “métricas prontas para uso”. Veja a seguir os documentos de referência para instalar o prometheus-operator: https://prometheus-operator.dev/ https://github.com/prometheus-operator/prometheus-operator

Sobre o autor

Jason WilliamsGerente Principal de Produto | F5

Mais publicações de Jason Williams