Verwalten Sie mehrere Dienste in runit-docker

einführen

runit ist ein leichter, stabiler und plattformübergreifender Service-Manager. Es wurde von Bruce Guenter entwickelt und wird derzeit von Laurent Bercot gepflegt. Das Design von runit ist einfach und unkompliziert, leicht zu verwenden und zu erweitern und eignet sich sehr gut für Daemons, die Dienste ausführen.

runit bietet eine einfache Möglichkeit, Systemdienste zu verwalten. Im Gegensatz zum herkömmlichen Init-System verwendet Runit keine Skriptdateien oder andere komplexe Konfigurationen zur Verwaltung von Diensten. Stattdessen verwaltet es den Betriebsstatus des Dienstes direkt über die Prozesstabelle des Betriebssystems und über ein bestimmtes Verzeichnis.

runit behandelt alle Dienste als unabhängige Prozesse, die über Shell-Skripte oder andere Sprachen gestartet werden können. Wenn der Dienst startet, überwacht runit seinen Ausführungsstatus und startet ihn neu, wenn der Dienst abstürzt oder beendet wird.

In ruanit wird jeder Dienst durch ein separates Verzeichnis repräsentiert. Dieses Verzeichnis enthält alle für den Dienst erforderlichen Informationen, z. B. Startskripte, Umgebungsvariablen usw. runit ist sehr flexibel und kann je nach Bedarf Dienste hinzufügen oder entfernen, Konfigurationsdateien ändern usw.

Offizielle Dokumentation: http://smarden.org/runit/

Runit, systemctl und Supervisor sind drei verschiedene Service-Management-Tools.

Runit:
Runit ist ein leichtes, plattformübergreifendes Service-Management-Tool zur Verwaltung und Überwachung von Systemdiensten. Es verwendet eine einfache Ordnerstruktur und Skripte zum Überwachen, Starten, Stoppen und Neustarten von Diensten. Runit konzentriert sich auf Zuverlässigkeit und Effizienz und unterstützt Abhängigkeiten zwischen Diensten. Jeder Dienst wird durch ein unabhängiges runit-Dienstverzeichnis dargestellt, das das zum Starten des Dienstes verwendete Ausführungsskript enthält. Runit ist nicht auf Linux-spezifische Systemfunktionen angewiesen und kann daher auch auf anderen UNIX-Systemen ausgeführt werden.

Systemd:
Systemd ist das gebräuchlichste Service-Management-Tool in Linux-Systemen und wird zur Verwaltung von Daemon-Prozessen und Systemdiensten verwendet. Es ist das Standardinitialisierungssystem für moderne Linux-Systeme mit leistungsstarken Funktionen und umfangreichem Support. Systemd verwendet eine einzige Konfigurationsdatei (.service-Datei), um Dienste zu definieren und zu verwalten. Es kann mehrere Dienste parallel starten, Dienstabhängigkeiten unterstützen und erweiterte Funktionen wie Socket-Aktivierung, Ressourcenlimits usw. bereitstellen. Systemd kann auch die von ihm gestarteten Prozesse verwalten und überwachen.

Supervisor:
Supervisor ist ein Prozessverwaltungstool, das hauptsächlich zur Verwaltung von Daemon-Prozessen oder Hintergrundaufgaben verwendet wird. Es unterscheidet sich von systemd und runit darin, dass es kein vollständiges Initialisierungssystem ist, sondern sich auf die Verwaltung eines einzelnen Prozesses konzentriert. Supervisor ermöglicht Ihnen die Definition und Überwachung mehrerer Prozesse und bietet eine einfache Möglichkeit, Prozesse zu starten, zu stoppen, neu zu starten und automatisch neu zu starten, wenn ein Prozess unerwartet beendet wird.

Zusammenfassen:

• Runit ist ein leichtes, plattformübergreifendes Dienstverwaltungstool, das sich zur Verwaltung von Systemdiensten und Abhängigkeiten zwischen Diensten eignet.
• Systemd ist das Standardinitialisierungssystem von Linux-Systemen, unterstützt das parallele Starten und Verwalten mehrerer Dienste und bietet erweiterte Funktionen.
• Supervisor ist ein Prozessverwaltungstool zur Verwaltung von Daemon-Prozessen oder Hintergrundaufgaben und kein vollständiges Initialisierungssystem.

Welches Tool Sie wählen, hängt von Ihren spezifischen Anforderungen und Ihrer Systemumgebung ab.

• Für Linux-Systeme wird normalerweise der Standardwert systemd verwendet.
• Für plattformübergreifende Anforderungen oder eine einfache Dienstverwaltung, beispielsweise die Überwachung mehrerer Dienste in einem Container, können Sie die Verwendung von runit in Betracht ziehen.
• Supervisor wird normalerweise zur Verwaltung eines einzelnen Hintergrundprozesses oder Daemons verwendet.

Runit-Vorteile

• Einfache Konfiguration und Verwendung : Die Konfiguration von runit ist einfach und unkompliziert und die Verwendung ist sehr einfach. Es verwendet Nur-Text-Konfigurationsdateien und erfordert keine komplexen Skripte oder Konfigurationssprachen, sodass Benutzer die Start- und Überwachungsregeln für Dienste schnell verstehen und definieren können.

• Schneller Start und geringer Ressourcenverbrauch : Runit startet sehr schnell, da es sich nur auf den Start und die Verwaltung von Diensten konzentriert und keine anderen redundanten Funktionen hat. Darüber hinaus sind der Speicher- und CPU-Verbrauch von runit sehr gering, sodass es für die Ausführung in ressourcenbeschränkten Umgebungen geeignet ist.

• Zuverlässigkeit und Stabilität : runit ist für seine Stabilität bekannt. Nach Jahren der Entwicklung und breiten Anwendung ist es weithin als zuverlässiges Service-Überwachungstool anerkannt. Das einfache Design und die modulare Architektur tragen dazu bei, das Ausfallrisiko zu verringern.

• Unterstützt den parallelen Start : Runit unterstützt den parallelen Start mehrerer Dienste. Dies bedeutet, dass beim Systemstart mehrere Dienste gleichzeitig gestartet werden können, wodurch die Systemstartgeschwindigkeit verbessert wird.

• Für verschiedene Systeme geeignet : runit kann auf einer Vielzahl von Betriebssystemen ausgeführt werden, darunter verschiedene Linux-Distributionen, FreeBSD usw., was es zu einer plattformübergreifenden Wahl macht.

• Fehlertoleranz und Robustheit : runit verfügt über einen Fehlertoleranzmechanismus, der abnormale Dienstausgänge und -neustarts verarbeiten und automatische Wiederherstellungsmaßnahmen ergreifen kann, wenn der Dienst abstürzt.

Programmzusammensetzung

• runvdir: Scannen Sie das Verzeichnis alle 5 Sekunden. Wenn ein neues Unterverzeichnis vorhanden ist, wird automatisch ein runv-Prozess erstellt, um den Dienst aufrechtzuerhalten.
• runv: Der Daemon-Prozess, der zum Verwalten des Dienstes verwendet wird. Der Dienst kann über den Befehl sv bedient werden.
• sv: CLI-Tool, das von Benutzern zum Betreiben von Diensten verwendet wird.
• svlogd: Daemon-Prozess zum Sammeln von Dienstprotokollen. Jeder Dienst startet einen svlogd-Prozess.

Schnellstart

Dienstüberwachung: Programm-Binärdateien überwachen

conf/runit-sv/php-fpm/run

#!/bin/bash
exec /usr/sbin/php-fpm8.2 --fpm-config /etc/php/8.2/fpm/php-fpm.conf -R

conf/runit-sv/nginx/run

#!/bin/bash
exec /usr/sbin/nginx

Docker-Datei

FROM ubuntu:18.04

RUN apt-get install -y runit \
    &&  mkdir -p /etc/service/nginx/  /etc/sv/nginx/ /etc/sv/php-fpm/

COPY conf/runit-sv/nginx/run /etc/service/nginx/run
RUN chmod 755  /etc/service/nginx/run

COPY conf/runit-sv/php-fpm/run /etc/service/php-fpm/run
RUN chmod 755  /etc/service/php-fpm/run

RUN  chmod 755  /etc/sv/nginx/run \
	&& chmod 755  /etc/sv/php-fpm/run \
	&& ln -s /etc/sv/charon /etc/service/  \
	&& ln -s /etc/sv/php-fpm/ /etc/service/  \
	&& ln -s /etc/sv/nginx/ /etc/service/

# 启动GAD
CMD ["/bin/docker-entrypoint.sh"]

/bin/docker-entrypoint.sh

exec runsvdir /etc/service &

runit implementiert den Service-Exit und führt bestimmte Vorgänge aus

runit verwendet den Befehl trap, um TERM- und INT-Signale zu erfassen. Wenn runit selbst verwendet wird, stoppt es den Dienst, wenn es das TERM-Signal empfängt. Manchmal wird es nicht wirksam. Sie können die benutzerdefinierte Erfassung von TERM- und INT-Signalen verwenden.

#!/bin/bash

stop_task() {
  killall nginx
  exit 0

}

trap stop_task TERM INT

/bin/sh -c 'trap stop_task TERM INT; /usr/sbin/nginx 2>&1 | /usr/bin/logger -n 127.0.0.1 -P 514 -t NGINX -d --rfc5424 '  &

wait $!

Der Runit-Überwachungsdienst druckt Protokolle im Syslog

#!/bin/bash
exec /usr/sbin/nginx  | /usr/bin/logger -n 127.0.0.1 -P 514 -t NGINX -d --rfc5424   2>&1

Der Runit-Überwachungsdienst läuft im Hintergrund

In runit ist das Ausführungsskript ein blockierender Befehl und das Skript wird erst beendet, wenn der Dienst beendet wird. Wenn Sie nach dem Start des Dienstes weitere Aufgaben ausführen müssen, können Sie die folgenden Methoden ausprobieren: Verwenden Sie einen Hintergrundprozess im Ausführungsskript, um den Dienst zu starten

Methode 1: Verwenden Sie das &-Symbol im Ausführungsskript, um den Dienststartbefehl im Hintergrundprozess auszuführen.

Zum Beispiel:

#!/bin/sh

# Start the service in the background
/usr/bin/my-service &

Der auf diese Weise gestartete Dienst wird im Hintergrund ausgeführt, ohne das Skript zu blockieren, sodass Sie andere Aufgaben im Skript ausführen können.

Methode 2: Verwenden Sie den Befehl nohup im Ausführungsskript.
Der Befehl nohup kann den Befehl im Hintergrundprozess ausführen und die Ausgabe in die angegebene Datei umleiten. Zum Beispiel:

#!/bin/sh

# Start the service in the background with nohup
nohup /usr/bin/my-service > /var/log/my-service.log 2>&1 &

# Other tasks to execute after the service starts
echo "My service has started."

Methode 3: Verwenden Sie den Befehl „wait“ im Ausführungsskript

Der Wartebefehl kann auf das Ende des angegebenen Prozesses warten und nach dem Ende des Prozesses weiterhin andere Befehle im Skript ausführen. Zum Beispiel:

#!/bin/sh

# Start the service and wait for it to finish
/usr/bin/my-service &
wait $!

# Other tasks to execute after the service finishes
echo "My service has finished."

In diesem Beispiel wartet der Befehl „wait“ auf das Ende des Prozesses „my-service“ und gibt den Exit-Statuscode von „my-service“ zurück. Nachdem der my-service-Prozess beendet ist, führt das Skript weiterhin andere Befehle aus.

Zusammenfassung einiger Fehler in Runit-Überwachungsdiensten

Hinweis: Für über apt-get installierte Dateien muss der Daemon manuell geschlossen werden, andernfalls wird er über sysinit gehostet.

daemon

Der PHP-FPM-Prozess wird daemonstandardmäßig im Modus gestartet. Wenn Runit zur Überwachung des Prozesses verwendet wird, darf der überwachte Prozess kein Daemon-Prozess sein.
Wir müssen den Prozess-Daemon von php-fpm ausschalten, /usr/local/php/etc/php-fpm.conf bearbeiten, daemonize finden und in „no“ ändern.

Fahren Sie fort, den Fehler zu sperren. Überprüfen Sie zunächst das PHP-FPM-Protokoll:

[01-Sep-2018 11:20:21] ERROR: unable to bind listening socket for address '127.0.0.1:9000': Address already in use (98)
[01-Sep-2018 11:20:21] ERROR: FPM initialization failed
[01-Sep-2018 11:20:23] ERROR: unable to bind listening socket for address '127.0.0.1:9000': Address already in use (98)
[01-Sep-2018 11:20:23] ERROR: FPM initialization failed
[01-Sep-2018 11:20:24] ERROR: unable to bind listening socket for address '127.0.0.1:9000': Address already in use (98)
[01-Sep-2018 11:20:24] ERROR: FPM initialization failed
[01-Sep-2018 11:20:25] ERROR: unable to bind listening socket for address '127.0.0.1:9000': Address already in use (98)
[01-Sep-2018 11:20:25] ERROR: FPM initialization failed

Wenn Runit den Dienst überwacht und es daher zu einer Situation kommt, in der das Susinit-Überwachungsprogramm nach der Installation über apt-get standardmäßig verwendet wird, müssen Sie den Standardstartmodus des Dienstes deaktivieren und seine Binärdatei über Runit überwachen.