Lösung für die Protokollpersistenzlösung des Nginx-Ingress-Controllers

Lösung für die Protokollpersistenzlösung des Nginx-Ingress-Controllers

Kürzlich habe ich auf einem öffentlichen Konto einen Artikel gesehen, in dem es um die Anwendung des Nginx-Ingress-Controllers ging. Unten hat jemand einen Kommentar dazu geschrieben, wie man Protokolle dauerhaft macht. Ich bin gerade bei der Arbeit auf dieses Problem gestoßen und habe eine Lösung für Sie zusammengestellt.

nginx-ingress-controller-Protokoll

Das Protokoll des nginx-ingress-controllers besteht aus drei Teilen:

  • Controller-Log: Ausgabe auf stdout. Die Ausgabe in eine Datei können Sie über --log_dir im Startparameter konfigurieren. Nach der Umleitung in eine Datei wird diese automatisch rotiert, aber nicht automatisch bereinigt.
  • accesslog: Ausgabe nach stdout. Die Ausgabedatei kann über die Felder in der nginx-Konfiguration konfiguriert werden. Die Ausgabe in die Datei wird nicht automatisch gedreht oder bereinigt
  • errorlog: Gibt an stderr aus. Die Konfigurationsmethode ist ähnlich wie bei accesslog.

Controller-Protokolle auf die Festplatte schreiben

  • Geben Sie nginx-ingress-controller einen Hostpfad: /data/log/nginx_ingress_controller/ wird im Container auf /var/log/nginx_ingress_controller/ abgebildet.
  • Konfigurieren Sie die Parameter log-dir und logtostderr für nginx-ingress-controller, um Protokolle nach /var/log/nginx_ingress_controller/ umzuleiten.

Die Controller-Protokolle müssen regelmäßig bereinigt werden. Da die Controller-Protokolle über klog (k8s.io/klog) ausgegeben werden, werden die Protokolle übertragen, sodass wir das Skript verwenden können, um die Protokolldateien regelmäßig vor einer bestimmten Zeit zu bereinigen.

Nginx-Protokolle auf die Festplatte schreiben

Konfigurationszuordnung ändern: nginx-configuration. Konfigurieren Sie den Ausgabepfad von Accesslog und Errorlog, um die Standardpfade stdout und stderr zu ersetzen. Der Ausgabepfad kann zur einfacheren Suche mit dem Controller übereinstimmen.

Sowohl Accesslog als auch Errorlog haben nur eine Protokolldatei. Wir können logrotate verwenden, um die Protokolle zu rotieren und die Protokollausgabe an den Hostcomputer zu rotieren und zu bereinigen. Konfigurationen wie:

$ cat /etc/logrotate.d/nginx.log
/data/log/nginx_ingress_controller/access.log {
  su-Stammliste
  drehen 7
  täglich
  maximale Größe 50M
  kopieren und abschneiden
  fehltok
  Erstellen Sie 0644 WWW-Datenstamm
}

In den offiziellen Vorlagen startet nginx-ingress-controller den Container standardmäßig mit der Anmeldung als Benutzer 33, sodass beim Mounten des Hostpath-Pfads ein Berechtigungsproblem auftritt. Wir müssen chown -R 33:33 /data/log/nginx_ingress_controller manuell auf der Maschine ausführen.

Automatisierte Operationen

Wenn Nginx-Protokolle auf die Festplatte geschrieben werden, erfordern die Punkte 2 und 3 manuelle Bedienung und Wartung. Gibt es eine Lösung?

Der Schlüssel zum Problem ist: Gibt es eine Möglichkeit, vor dem Start des Containers „nginx-ingress-controller“ einen Hook hinzuzufügen, um das angegebene Verzeichnis des Hostcomputers zu chownen?

Sie können initContainer verwenden. initcontainer muss vollständig ausgeführt und erfolgreich beendet werden, bevor die Container in Containern ausgeführt werden. Mit dieser K8s-Funktion entwickeln wir ein Docker-Image, das nur die folgenden Skripte ausführt:

#!/bin/bash
logdir=$LOG_DIR
Benutzer-ID=$USER_ID
echo "versuche, die Gruppe von dir: $logdir als $userID festzulegen"
chown -R $Benutzer-ID:$Benutzer-ID $logdir

Das Skript liest einige Umgebungsvariablen, um zu bestimmen, welches Verzeichnis geändert werden muss und zu welcher Benutzergruppe gewechselt werden soll.

Packen Sie das Skript in ein Docker-Image und fügen Sie es als Initcontainer in das Bereitstellungs-YAML des Nginx-Ingress-Controllers ein. Beachten Sie, dass Sie Umgebungsvariablen und VolumeMount für den Initcontainer konfigurieren müssen.

Was den zweiten Punkt betrifft, haben wir festgestellt, dass das Basisimage von nginx-ingress-controller mit logrotate geliefert wird. Das Problem ist also einfach. Wir müssen nur die geschriebene logrotate-Konfigurationsdatei in Form einer Configmap in den Container mounten.

Eine Bereitstellungs-YAML sieht wie folgt aus:

---
API-Version: v1
Art: Dienstleistung
Metadaten:
 Name: ingress-nginx
 Namespace: Kube-System
Spezifikation:
 Typ: ClusterIP
 Häfen:
 - Name: http
  Anschluss: 80
  ZielPort: 80
  Protokoll: TCP
 - Name: https
  Port: 443
  ZielPort: 443
  Protokoll: TCP
 Wähler:
  App: ingress-nginx
---
API-Version: v1
Art: Dienstleistung
Metadaten:
 Name: Standard-http-Backend
 Namespace: Kube-System
 Beschriftungen:
  App: Standard-HTTP-Backend
Spezifikation:
 Häfen:
 - Anschluss: 80
  ZielPort: 8080
 Wähler:
  App: Standard-HTTP-Backend
---
API-Version: Erweiterungen/v1beta1
Art: Ingress
Metadaten:
 Name: Standard
 Namespace: Kube-System
Spezifikation:
 Backend:
  Dienstname: Standard-http-backend
  ServicePort: 80
---
Art: ConfigMap
API-Version: v1
Metadaten:
 Name: nginx-Konfiguration
 Namespace: Kube-System
 Beschriftungen:
  App: ingress-nginx
Daten:
 Weitergeleitete Header verwenden: „true“
 # Konfigurieren Sie hier das Umleitungsziel des Nginx-Protokolls: access-log-path: /var/log/nginx_ingress_controller/access.log
 Fehlerprotokollpfad: /var/log/nginx_ingress_controller/error.log

---

# Erstellen Sie eine ConfigMap, um die Rotationsstrategie der Nginx-Protokolle zu konfigurieren, die der Protokolldatei-API-Version: v1 der Nginx-Protokolle im Container entspricht.
Daten:
 nginx.log: |
  {{ user_nginx_log.host_path }}/access.log {
    drehen {{ user_nginx_log.rotate_count }}
    täglich
    maximale Größe {{ user_nginx_log.rotate_size }}
    Mindestgröße 10M
    kopieren und abschneiden
    fehltok
    erstellen 0644 root root
  }
  {{ user_nginx_log.host_path }}/error.log {
    drehen {{ user_nginx_log.rotate_count }}
    täglich
    maximale Größe {{ user_nginx_log.rotate_size }}
    Mindestgröße 10M
    kopieren und abschneiden
    fehltok
    erstellen 0644 root root
  }
Art: ConfigMap
Metadaten:
 Name: nginx-ingress-logrotate
 Namespace: Kube-System
---

Art: ConfigMap
API-Version: v1
Metadaten:
 Name: TCP-Dienste
 Namespace: Kube-System
---
Art: ConfigMap
API-Version: v1
Metadaten:
 Name: UDP-Dienste
 Namespace: Kube-System
---
API-Version: v1
Art: ServiceAccount
Metadaten:
 Name: nginx-ingress-serviceaccount
 Namespace: Kube-System
---
API-Version: rbac.authorization.k8s.io/v1beta1
Art: ClusterRole
Metadaten:
 Name: nginx-ingress-clusterrole
Regeln:
 -API-Gruppen:
   - ""
  Ressourcen:
   - Konfigurationskarten
   - Endpunkte
   - Knoten
   - Schoten
   - Geheimnisse
  Verben:
   - Liste
   - betrachten
 -API-Gruppen:
   - ""
  Ressourcen:
   - Knoten
  Verben:
   - erhalten
 -API-Gruppen:
   - ""
  Ressourcen:
   - Dienstleistungen
  Verben:
   - erhalten
   - Liste
   - betrachten
 -API-Gruppen:
   - "Erweiterungen"
  Ressourcen:
   - Eingänge
  Verben:
   - erhalten
   - Liste
   - betrachten
 -API-Gruppen:
   - ""
  Ressourcen:
    - Veranstaltungen
  Verben:
    - erstellen
    -Patch
 -API-Gruppen:
   - "Erweiterungen"
  Ressourcen:
   - Eingänge/Status
  Verben:
   - aktualisieren
---
API-Version: rbac.authorization.k8s.io/v1beta1
Art: Rolle
Metadaten:
 Name: nginx-ingress-Rolle
 Namespace: Kube-System
Regeln:
 -API-Gruppen:
   - ""
  Ressourcen:
   - Konfigurationskarten
   - Schoten
   - Geheimnisse
   - Namensräume
  Verben:
   - erhalten
 -API-Gruppen:
   - ""
  Ressourcen:
   - Konfigurationskarten
  Ressourcennamen:
   # Der Standardwert ist „<Wahl-ID>-<Eingangsklasse>“
   # Hier: „<ingress-controller-leader>-<nginx>“
   # Dies muss angepasst werden, wenn Sie einen der Parameter ändern
   # beim Starten des Nginx-Ingress-Controllers.
   - "Ingress-Controller-Leader-Nginx"
  Verben:
   - erhalten
   - aktualisieren
 -API-Gruppen:
   - ""
  Ressourcen:
   - Konfigurationskarten
  Verben:
   - erstellen
 -API-Gruppen:
   - ""
  Ressourcen:
   - Endpunkte
  Verben:
   - erhalten
---
API-Version: rbac.authorization.k8s.io/v1beta1
Art: RoleBinding
Metadaten:
 Name: nginx-ingress-role-nisa-binding
 Namespace: Kube-System
Rollenreferenz:
 API-Gruppe: rbac.authorization.k8s.io
 Art: Rolle
 Name: nginx-ingress-Rolle
Themen:
 - Art: ServiceAccount
  Name: nginx-ingress-serviceaccount
  Namespace: Kube-System
---
API-Version: rbac.authorization.k8s.io/v1beta1
Art: ClusterRoleBinding
Metadaten:
 Name: nginx-ingress-clusterrole-nisa-binding
Rollenreferenz:
 API-Gruppe: rbac.authorization.k8s.io
 Art: ClusterRole
 Name: nginx-ingress-clusterrole
Themen:
 - Art: ServiceAccount
  Name: nginx-ingress-serviceaccount
  Namespace: Kube-System
---
API-Version: Apps/v1
Art: DaemonSet
Metadaten:
 Name: ingress-nginx
 Namespace: Kube-System
Spezifikation:
 Wähler:
  Übereinstimmungsetiketten:
   App: ingress-nginx
 Vorlage:
  Metadaten:
   Beschriftungen:
    App: ingress-nginx
   Anmerkungen:
    prometheus.io/port: '10254'
    prometheus.io/scrape: "wahr"
  Spezifikation:
   Dienstkontoname: nginx-ingress-serviceaccount
   Toleranzen:
   - Taste: dediziert
    Wert: ingress-nginx
    Effekt: NoSchedule
   Affinität:
    Knotenaffinität:
     erforderlich während der Planung, ignoriert während der Ausführung:
      nodeSelectorTerms:
      - Übereinstimmungsausdrücke:
       - Schlüssel: „System/Ingress“
        Betreiber: In
        Werte:
        - "WAHR"
   DNS-Richtlinie: ClusterFirstWithHostNet
   hostNetwork: wahr
   # Konfigurieren Sie initcontainer, um sicherzustellen, dass die Berechtigungen des Protokollverzeichnisses konfiguriert sind, bevor der Container nginx-ingress-controller gestartet wird initContainers:
   - Name: adddirperm
    Bild: "{{ image_registry.addr }}/{{ image.adddirperm }}"
    Umgebung:
    - Name: LOG_DIR
     Wert: /var/log/nginx_ingress_controller
    - Name: USER_ID
      Wert: „33“
    Volumenhalterungen:
    - Name: logdir
     Mount-Pfad: /var/log/nginx_ingress_controller
   Behälter:
   - Name: nginx-ingress-controller
    Bild: "{{ image_registry.addr }}/{{ image.ingress }}"
    imagePullPolicy: IfNotPresent
    Argumente:
    - /nginx-ingress-controller
    - --default-backend-service=$(POD_NAMESPACE)/default-http-backend
    – –configmap=$(POD_NAMESPACE)/nginx-Konfiguration
    - --tcp-services-configmap=$(POD_NAMESPACE)/tcp-services
    - --udp-services-configmap=$(POD_NAMESPACE)/udp-services
    – –publish-service=$(POD_NAMESPACE)/ingress-nginx
    - --annotations-prefix=nginx.ingress.kubernetes.io
    
    # Legen Sie den Ausgabepfad und die Methode des Controller-Protokolls fest - --log_dir=/var/log/nginx_ingress_controller
    - --logtostderr=false
    Sicherheitskontext:
     Fähigkeiten:
       fallen:
       - ALLE
       hinzufügen:
       -NET_BIND_SERVICE
     # www-Daten -> 33
     Als Benutzer ausführen: 33
    Umgebung:
     - Name: POD_NAME
      Wert von:
       FeldRef:
        Feldpfad: Metadatenname
     - Name: POD_NAMESPACE
      Wert von:
       FeldRef:
        Feldpfad: metadata.namespace
    Häfen:
    - Name: http
     ContainerPort: 80
    - Name: https
     ContainerPort: 443
    Ressourcen:
     Anfragen:
      CPU: 100 M
      Speicher: 256Mi
    LivenessProbe:
     Fehlerschwelle: 3
     httpGet:
      Pfad: /healthz
      Port: 10254
      Schema: HTTP
     AnfangsverzögerungSekunden: 10
     PeriodeSekunden: 10
     Erfolgsschwelle: 1
     TimeoutSekunden: 1
    Bereitschaftsprobe:
     Fehlerschwelle: 3
     httpGet:
      Pfad: /healthz
      Port: 10254
      Schema: HTTP
     PeriodeSekunden: 10
     Erfolgsschwelle: 1
     TimeoutSekunden: 1
    Volumenhalterungen:
    #Konfigurieren Sie den Protokollausgabepfad der Controllerkomponente und von nginx im gemounteten Container - Name: logdir
     Mount-Pfad: /var/log/nginx_ingress_controller
    #Konfigurieren Sie den Logrotate-Konfigurations-Mount-Pfad für Nginx-Protokolle - Name: logrotateconf
     Mount-Pfad: /etc/logrotate.d/nginx.log
     Unterpfad: nginx.log
   Bände:
   # Der Protokollausgabepfad der Controllerkomponente und von nginx ist der Hostpfad des Hostcomputers
   - Name: logdir
    Hostpfad:
     Pfad: {{ user_nginx_log.host_path }}
     Typ: ""
   # Die Rotationskonfigurationsdatei des Nginx-Protokolls stammt aus Configmap
   - Name: logrotateconf
    Konfigurationskarte:
     Name: nginx-ingress-logrotate
     Artikel:
     - Schlüssel: nginx.log
      Pfad: nginx.log
---

API-Version: Apps/v1
Art: DaemonSet
Metadaten:
 Name: Standard-http-Backend
 Namespace: Kube-System
 Beschriftungen:
  App: Standard-HTTP-Backend
Spezifikation:
 Wähler:
  Übereinstimmungsetiketten:
   App: Standard-HTTP-Backend
 Vorlage:
  Metadaten:
   Beschriftungen:
    App: Standard-HTTP-Backend
  Spezifikation:
   KündigungsfristSekunden: 60
   Toleranzen:
   - Taste: dediziert
    Wert: ingress-nginx
    Effekt: NoSchedule
   Affinität:
    Knotenaffinität:
     erforderlich während der Planung, ignoriert während der Ausführung:
      nodeSelectorTerms:
      - Übereinstimmungsausdrücke:
       - Schlüssel: „System/Ingress“
        Betreiber: In
        Werte:
        - "WAHR"
   Behälter:
   - Name: Standard-http-Backend
    # Jedes Bild ist zulässig, solange:
    # 1. Es liefert eine 404-Seite unter /
    # 2. Es bedient 200 auf einem /healthz-Endpunkt
    Bild: "{{ image_registry.addr }}/{{ image.http_backend }}"
    imagePullPolicy: IfNotPresent
    LivenessProbe:
     httpGet:
      Pfad: /healthz
      Port: 8080
      Schema: HTTP
     AnfangsverzögerungSekunden: 30
     TimeoutSekunden: 5
    Häfen:
    - ContainerPort: 8080
    Ressourcen:
     Grenzen:
      Zentralprozessor: 10 M
      Speicher: 20mi
     Anfragen:
      Zentralprozessor: 10 M
      Speicher: 20mi
---

Schließlich schlugen einige Leute vor, den Initcontainer zu entfernen und eine Ebene basierend auf dem ursprünglichen Nginx-Ingress-Controller-Image hinzuzufügen und das Skript zum Konfigurieren der Pfadberechtigungen in dieser Ebene auszuführen. Persönlich finde ich diese Methode weder schön noch bequem. Der einzige Vorteil besteht darin, dass das Bereitstellungs-YAML immer noch präzise ist (Konfigurationen wie VolumeMount sind jedoch unverzichtbar). Aber es hängt von der persönlichen Erfahrung ab~

Dies ist das Ende dieses Artikels über die Lösung für die Protokollpersistenz des nginx-Ingress-Controllers. Weitere Informationen zur Protokollpersistenz des nginx-Ingress-Controllers finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • Artefakt! Bestes Nginx-Protokollanalysetool GoAccess
  • Detaillierte Erläuterung der Idee des Rollens von Nginx-Protokollen in Docker
  • Detaillierte Methode zur Verwendung von GoAccess zum Analysieren von Nginx-Protokollen

<<:  JavaScript navigator.userAgent erhält Browserinformationen – Fallerklärung

>>:  Detaillierte Erläuterung zum Erstellen einer Ansicht (CREATE VIEW) und zu Nutzungsbeschränkungen in MySQL

Artikel empfehlen

So ändern Sie $ in # in Linux

In diesem System steht das #-Zeichen für den Root...

Detaillierte Schritte zum Erstellen eines Dateiservers in Windows Server 2012

Der Dateiserver ist einer der am häufigsten verwe...

Mit wie vielen Pixeln sollte eine Webseite gestaltet werden?

Viele Webdesigner sind beim Entwurf des Webseitenl...

Detailliertes Tutorial zum PyCharm- und SSH-Remote-Access-Server-Docker

Hintergrund: Einige Experimente müssen auf dem Se...

5 MySQL-GUI-Tools, die Ihnen bei der Datenbankverwaltung empfohlen werden

Es gibt viele Datenbankverwaltungstools für MySQL...

Allgemeine Textverarbeitungsbefehle unter Linux und Vim-Texteditor

Lassen Sie uns heute einige gängige Textverarbeit...

So aktualisieren Sie https unter Nginx

Kaufzertifikat Sie können es beim Cloud Shield Ce...

MySQL5.7.27-winx64 Version Win10 Download- und Installations-Tutorial-Diagramm

MySQL 5.7-Installation Wir lernen in der Schule M...

So installieren Sie MySQL und Redis in Docker

Dieser Artikel basiert auf der CentOS 7.3-Systemu...

Einführung in den strikten Modus von JavaScript verwenden Sie strikt

Inhaltsverzeichnis 1. Übersicht 1.1 Was ist der s...

So implementieren Sie „insert if none“ und „update if yes“ in MySql

Zusammenfassung In einigen Szenarien kann eine so...

CSS Flex mehrere mehrspaltige Layouts

Grundlegendes dreispaltiges Layout .Container{ An...

Detaillierte Erklärung der CocosCreator MVC-Architektur

Überblick Dieser Artikel stellt die in Spieleclie...

Langsame MySQL-Abfragen und Protokolleinstellungen und -tests

1. Einleitung Durch Aktivieren des Slow Query Log...