Surveillance et journalisation des services externes au cluster Kubernetes

Bon à tous.

Je n'ai pas trouvé de guide généralisé en ligne sur la journalisation et la collecte de métriques de services tiers dans les systèmes déployés dans Kubernetes. Je publie ma solution. Cet article suppose que vous disposez déjà d'un Prométhée et d'autres services. À titre d'exemple de source de données pour un service avec état externe, un SGBD sera utilisé PostgreSQL dans un conteneur Docker. L'entreprise utilise un gestionnaire de packages Casque, ci-dessous dans le texte, il y aura des exemples à ce sujet. Pour l'ensemble de la solution, nous préparons notre propre graphique, qui comprend des graphiques imbriqués de tous les services utilisés.

Enregistrement

De nombreuses entreprises utilisent une pile de technologies pour collecter, visualiser et centraliser les journaux ElasticSearch + Logstash + Kibana, abrégé en ELK. Dans notre cas, il n’est pas nécessaire d’indexer le contenu et j’ai utilisé un langage plus léger Loki. Il est disponible sous forme de package Helm, nous l'avons ajouté en tant que sous-graphique en modifiant les valeurs d'entrée et de pv en fonction de notre système.

valeurs.yaml

ingress:
  enabled: true
  annotations:
     kubernetes.io/ingress.class: nginx
  hosts:
    - host: kube-loki.example.domain
      paths: 
        - /
  tls: []

....

persistence:
  type: pvc
  enabled: true
  accessModes:
    - ReadWriteOnce
  size: 100Gi
  finalizers:
    - kubernetes.io/pvc-protection
  existingClaim: "pv-loki"

Pour envoyer des journaux à une instance Loki utilisation Pilote de journalisation Loki Docker.

Vous devez installer ce module complémentaire sur tout Docker hôtes à partir desquels vous souhaitez recevoir des journaux. Il existe plusieurs façons d'indiquer au démon comment utiliser le remplissage. Je sélectionne le pilote dans yaml Docker Compose, qui fait partie de Ansible livre de jeu.

postgres.yaml

    - name: Run containers
      docker_compose:
        project_name: main-postgres
        definition:
          version: '3.7'
          services:
            p:
              image: "{{ postgres_version }}"
              container_name: postgresql
              restart: always
              volumes:
                - "{{ postgres_dir }}/data:/var/lib/postgresql/data"
                - "{{ postgres_dir }}/postgres_init_scripts:/docker-entrypoint-initdb.d"
              environment:
                POSTGRES_PASSWORD: {{ postgres_pass }}
                POSTGRES_USER: {{ postgres_user }}
              ports:
                - "{{ postgres_ip }}:{{ postgres_port }}:5432"
              logging:
                driver: "loki"
                options:
                  loki-url: "{{ loki_url }}"
                  loki-batch-size: "{{ loki_batch_size }}"
                  loki-retries: "{{ loki_retries }}"
...

où loki_url : kube-loki.example.domain/loki/api/v1/push

Métrique

Les métriques sont collectées à partir de PostgreSQL à l'aide postgres_exporter pour Prométhée. Suite du dossier ci-dessus Ansible livre de jeu.

postgres.yaml

...
            pexp:
              image: "wrouesnel/postgres_exporter"
              container_name: pexporter
              restart: unless-stopped
              environment:
                DATA_SOURCE_NAME: "postgresql://{{ postgres_user }}:{{ postgres_pass }}@p:5432/postgres?sslmode=disable"
              ports:
                - "{{ postgres_ip }}:{{ postgres_exporter_port }}:9187"
              logging:
                driver: "json-file"
                options:
                  max-size: "5m"
...

Pour plus de clarté, nous écrirons les noms des services externes avec état à l'aide de Endpoints.

postgres-service.yaml

apiVersion: v1
kind: Endpoints
metadata:
  name: postgres-exporter
subsets:
  - addresses:
      - ip: {{ .Values.service.postgres.ip }}
    ports:
      - port: {{ .Values.service.postgres.port }}
        protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: postgres-exporter
  labels:
    chart:  "{{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}"
spec:
  ports:
    - protocol: TCP
      port: {{ .Values.service.postgres.port }}
      targetPort: {{ .Values.service.postgres.port }}

La configuration de Prometheus pour recevoir les données postgres_exporter se fait en modifiant les valeurs dans le sous-graphique.

valeurs.yaml

scrape_configs:
...
  - job_name: postgres-exporter
    static_configs:
      - targets: 
         - postgres-exporter.applicationnamespace.svc.cluster.local:9187
        labels:
          alias: postgres
...

Pour visualiser les données reçues, installez le tableau de bord approprié dans
grafana et configurer les sources de données. Cela peut également être fait via les valeurs du sous-graphique Grafana.

À quoi ça ressemble

J'espère que ce court article vous a aidé à comprendre les idées principales derrière cette solution et vous a fait gagner du temps lors de la configuration de la surveillance et de la journalisation des services externes pour Loki/Prometheus dans un cluster Kubernetes.

Source: habr.com