Application Real-Time Monitoring Service:Crie descoberta de serviço com um ServiceMonitor

Demonstração

Baixe o projeto de demonstração para obter um exemplo completo de descoberta de serviço baseada em ServiceMonitor.

Etapa 1: Adicionar dependências

1. Crie uma aplicação Maven e adicione as seguintes dependências ao arquivo pom.xml.

       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-actuator</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
               <groupId>io.micrometer</groupId>
               <artifactId>micrometer-registry-prometheus</artifactId>
               <version>1.6.6</version>
           </dependency>
   
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-configuration-processor</artifactId>
               <optional>true</optional>
           </dependency>
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <optional>true</optional>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>

2. Adicione a seguinte configuração ao arquivo src/resources/applications.properties do projeto.

   management.endpoints.web.exposure.include=prometheus

3. Inicie o projeto e acesse http://{host}:{port}/actuator/prometheus no navegador.

   Os dados de monitoramento da JVM são exibidos.

Etapa 2: Implantar um cluster Kubernetes

1. Construa uma imagem e envie-a para um repositório de imagens. Para mais informações, consulte Conectar-se a uma plataforma de código-fonte.

2. Crie um deployment usando a seguinte configuração YAML.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: micrometer-prometheus
     namespace: default
     labels:
       app: demo-prometheus
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: demo-prometheus
     template:
       metadata:
         labels:
           app: demo-prometheus
       spec:
         containers:
           - name: micrometer-prometheus
             image: manjusakalza/micrometer-prometheus:latest
             ports:
               - containerPort: 8080

3. Crie um Service usando a seguinte configuração YAML.

   apiVersion: v1
   kind: Service
   metadata:
     name: prometheus-metrics-demo
     namespace: default
     labels:
       micrometer-prometheus-discovery: 'true'
   spec:
     selector:
       app: demo-prometheus
     ports:
       - protocol: TCP
         port: 8080
         targetPort: 8080
         name: metrics

Etapa 3: Criar um ServiceMonitor

1. Salve o arquivo YAML no seu computador e execute kubectl apply -f {path/to/the/YAML/file} para aplicar o arquivo.

Exemplo de YAML do ServiceMonitor:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: micrometer-demo
  namespace: default
spec:
  endpoints:
    - interval: 15s
      path: /actuator/prometheus
      port: metrics    # Note: Configure the port name, not the port number.
  namespaceSelector:
    any: true
  selector:
    matchLabels:
      micrometer-prometheus-discovery: 'true'

Descrição dos campos YAML:

• Os campos name e namespace dentro de metadata identificam o ServiceMonitor.

• O campo endpoints em spec define os alvos de coleta. Cada endpoint no array endpoints (que aceita múltiplas entradas em endpoints) contém os seguintes campos:

  • interval: Intervalo de coleta para este endpoint. Exemplo: 15s.

  • path: Caminho de coleta das métricas. Exemplo: /actuator/prometheus.

  • port: Nome da porta do Service (deve corresponder ao name definido no seu Service na Etapa 2). Exemplo: metrics.

    Importante

    Configure o nome da porta, não o número da porta.

• O campo namespaceSelector em spec define o escopo da descoberta de Services. O namespaceSelector aceita dois campos mutuamente exclusivos:

  • any: Defina como true para monitorar todos os Services correspondentes em todos os namespaces.

  • matchNames: Restringe o monitoramento a namespaces específicos. Por exemplo, para monitorar apenas os namespaces default e arms-prom, configure matchNames da seguinte forma:

    namespaceSelector:
      matchNames:
      - default
      - arms-prom

• O campo selector em spec filtra Services por rótulo.

  Como o Service de exemplo possui o rótulo micrometer-prometheus-discovery: 'true', configure o selector conforme abaixo:

  selector:
    matchLabels:
      micrometer-prometheus-discovery: 'true'

Para ativar a autenticação básica, use o seguinte YAML:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: cloud-open-api-monitor     #  Set a unique name for the ServiceMonitor.
  namespace: default   #  Set the namespace where the ServiceMonitor resides.
spec:
  endpoints:
  - interval: 30s
    # Specify the interval at which Prometheus scrapes the current endpoint.
    port: tcp-8080
    # Enter the path exposed in the Prometheus exporter code.
    path: /api/actuator/prometheus
    basicAuth:
      password:
        name: basic-auth
        key: <password>
      username:
        name: basic-auth
        key: <userName>
    scheme: http
  namespaceSelector:
    any: true
  selector:
    matchLabels:
      # Match Services with the following label.
      edas.oam.acname: cloud-open-api

Se você não tiver permissões para autenticação básica, crie um ClusterRole com as permissões necessárias e vincule-o à ServiceAccount arms-prom-operator no namespace arms-prom usando um ClusterRoleBinding.

• Arquivo YAML do ClusterRole

  apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRole
  metadata:
    name: prometheus-agent-role
    labels:
      app: prometheus-agent
  rules:
    - apiGroups: [""]
      resources: ["pods", "services", "endpoints", "nodes"]
      verbs: ["get", "list", "watch"]  # Adjust as needed.
    - apiGroups: ["monitoring.coreos.com"]  # Adjust the apiGroups as needed.
      resources: ["*"]
      verbs: ["get", "list", "watch", "create", "update", "delete"]  # Adjust as needed.
  

• Arquivo YAML do ClusterRoleBinding

  apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRoleBinding
  metadata:
    name: prometheus-agent-binding
  subjects:
    - kind: ServiceAccount
      name: arms-prom-operator  # Service account name
      namespace: arms-prom      # The namespace where the service account resides.
  roleRef:
    kind: ClusterRole
    name: prometheus-agent-role  # The name of the ClusterRole defined above.
    apiGroup: rbac.authorization.k8s.io
  

Etapa 4: Verificar o ServiceMonitor

Verifique se o Prometheus descobriu seu serviço:

1. Faça login no console do ARMS. No painel de navegação à esquerda, clique em Integration Management.

2. Na aba Integrated Environments, clique no nome do ambiente de contêiner desejado na lista Container Service.

3. Clique na aba Self-Monitoring.

   Na aba Targets, verifique se existe um alvo chamado {namespace}/{serviceMonitorName}/x.

4. Expanda a linha do alvo {namespace}/{serviceMonitorName}/x e clique no link do endpoint.

   Verifique se as métricas são exibidas corretamente.

Referências