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:

apiVersão: v1
tipo: Serviço
metadados:
nome: nginx-ingress-servicemonitor
rótulos:
aplicativo: nginx-ingress-servicemonitor
especificação:
portas:
-nome: prometheus
protocolo: TCP
porta: 9113
Porta de destino: 9113
seletor:
aplicativo: 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
tipo: ServiceMonitor
metadados:
nome: nginx-ingress-servicemonitor
rótulos:
aplicativo: nginx-ingress-servicemonitor
especificação:
seletor:
matchLabels:
aplicativo: nginx-ingress-servicemonitor
pontos de extremidade:
-porta: 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
tipo: Prometheus
metadados:
nome: prometheus
rótulos:
prometheus: prometheus
especificação:
réplicas: 1
serviceAccountName: prometheus
serviceMonitorNamespaceSelector: {}
serviceMonitorSelector:
matchLabels:
app: nginx-ingress-servicemonitor
recursos:
solicitações:
memória: 500 milhas

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
tipo: Prometheus
metadados:
nome: prometheus
namespace: default
rótulos:
prometheus: monitoramento
especificação:
réplicas: 1
serviceAccountName: prometheus
serviceMonitorNamespaceSelector: {}
serviceMonitorSelector:
matchLabels:
app: nginx-ingress-servicemonitor
recursos:
solicitações:
memória: 500 milhas

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 :

O suporte a `servicemonitor` foi adicionado recentemente ao gráfico do leme do controlador NGINX Ingress. 
prometheus:
## Expõe métricas NGINX ou NGINX Plus no formato Prometheus.
create: true

## Configura a porta para extrair as métricas.
port: 9113

secret: ""

## Configura o esquema HTTP usado.
scheme: http

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

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

Separando os valores acima:

prometheus:
## Exponha métricas NGINX ou NGINX Plus no formato Prometheus.
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:
## Cria um ClusterIP Service para expor métricas do Prometheus internamente
## Requer 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:
## Cria um serviceMonitor para expor estatísticas nos pods do kubernetes.
create: true
## Rótulos de objetos do Kubernetes para anexar ao objeto serviceMonitor.
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