Überwachen der Integrität deiner Clusterknoten mit dem Knotenberechtigungsdienst

Informationen zu Node Eligibility Service

In einem GitHub Enterprise Server Cluster kann ein einzelner Knoten aufgrund eines Hardware- oder Softwarefehlers von anderen Knoten nicht erreichbar sein. Selbst wenn du die Integrität des Knotens wiederherstellst, kann sich die nachfolgende Synchronisierung der Daten nach einiger Zeit negativ auf die Leistung deiner Instanz auswirken.

Sie können die Auswirkungen der reduzierten Knotenverfügbarkeit proaktiv verringern, indem Sie dies verwenden Node Eligibility Service. Dieser Dienst überwacht den Status der Knoten deines Clusters und gibt eine Warnung aus, wenn ein Knoten zu lange offline war. Du kannst auch verhindern, dass ein Offlineknoten wieder in den Cluster eingeführt wird. Optional können Sie zulassen Node Eligibility Service , dass nicht zulässige Knoten offline sind.

Standardmäßig ist Node Eligibility Service deaktiviert. Wenn Sie diese Option aktivieren Node Eligibility Service, benachrichtigt Ihre Instanz Sie über fehlerhafte Knoten, indem sie ein Banner in der Administrativen Webbenutzeroberfläche für GitHub Enterprise Serverund in der CLI-Ausgabe für einige clusterbezogene Dienstprogramme anzeigen, z ghe-config-apply . B. und ghe-cluster-diagnostics.

Node Eligibility Service ermöglicht es Ihnen, die Integrität einzelner Knoten zu überwachen. Außerdem kannst du die allgemeine Integrität deines Clusters überwachen. Weitere Informationen finden Sie unter Überwachen der Gesundheit Ihres Clusters.

Informationen zur Gesundheit und Eignung von Clusterknoten

Um festzustellen, ob eine Warnung ausgegeben oder die Konfiguration des Clusters automatisch angepasst werden soll, Node Eligibility Service überwacht die Integrität jedes Knotens kontinuierlich. Jeder Knoten meldet regelmäßig einen Zeitstempelstatus, der Node Eligibility Service mit einer Dauer von Time To Live (TTL) verglichen wird.

Jeder Knoten verfügt über einen Integritätszustand und einen Eignungsstatus.

Gesundheit bezieht sich auf die Zugänglichkeit des Knotens innerhalb des Clusters und hat drei mögliche Zustände: healthy, warning oder critical.
Berechtigung bezieht sich darauf, dass der Knoten innerhalb des Clusters arbeiten kann, und weist zwei mögliche Zustände auf: eligible oder ineligible.

Node Eligibility Service bietet eine konfigurierbare TTL-Einstellung für zwei Zustände warn und fail.

warn: Der Knoten war für einen kurzen Zeitraum offline. Dies kann darauf hindeuten, dass mit dem Knoten etwas nicht stimmt und dass ihn ein Administrator untersuchen sollte. Die Standardeinstellung lautet 15 Minuten.
fail: Der Knoten war über einen längeren Zeitraum offline, und das Wiedereinführen in den Cluster kann aufgrund einer erneuten Synchronisierung zu Leistungsproblemen führen. Die Standardeinstellung lautet 60 Minuten.

Bestimmt für jeden Knoten die Node Eligibility Service Integrität und Berechtigung für die Teilnahme am Cluster auf folgende Weise.

Wenn ein Knoten als gesund festgestellt wurde, lautet der Gesundheitszustand healthy und der Zugriffsstatus eligible.
Wenn ein Knoten länger als die warn-TTL nicht als funktionsfähig beobachtet wurde, lautet der Integritätszustand warning und der Berechtigungsstatus eligible.
Wenn bei einem Knoten länger als die fail-TTL keine Anzeichen von Gesundheit beobachtet wurden, wird sein Gesundheitszustand als critical und sein Berechtigungsstatus als ineligible festgelegt.

Aktivieren Node Eligibility Service des Clusters

Standardmäßig ist Node Eligibility Service deaktiviert. Sie können dies aktivieren Node Eligibility Service , indem Sie den Wert für app.nes.enabled die Verwendung ghe-configfestlegen.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, melden Sie sich per SSH bei einem beliebigen Knoten Ihres Clusters an. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen finden Sie unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Um zu überprüfen, ob Node Eligibility Service derzeit aktiviert ist, führen Sie den folgenden Befehl aus.
Shell
```
ghe-config app.nes.enabled
```
```
ghe-config app.nes.enabled
```
Führen Sie zum Aktivieren Node Eligibility Serviceden folgenden Befehl aus.
Shell
```
ghe-config app.nes.enabled true
```
```
ghe-config app.nes.enabled true
```
Führe den folgenden Befehl aus, um die Konfiguration anzuwenden.

Hinweis

Während einer Konfigurationsausführung können die Dienste auf Ihre GitHub Enterprise Server-Instance neu gestartet werden, was zu kurzen Ausfallzeiten für Benutzer führen kann.
Shell
```
ghe-config-apply
```
```
ghe-config-apply
```
Warten Sie auf den Abschluss der Konfigurationsausführung.
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Node Eligibility Service der Knoten ausgeführt wird.
Shell
```
nomad status nes
```
```
nomad status nes
```

Konfigurieren von TTL-Einstellungen für Node Eligibility Service

Um zu ermitteln, wie Node Eligibility Service Sie benachrichtigt werden, können Sie TTL-Einstellungen für fail und warn Zustände konfigurieren. Der TTL-Wert für den fail-Status muss höher sein als der TTL-Wert für den warn-Status.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, melden Sie sich per SSH bei einem beliebigen Knoten Ihres Clusters an. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen finden Sie unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Führe den folgenden Befehl aus, um die aktuellen TTL-Einstellungen zu überprüfen.
Shell
```
nes get-node-ttl all
```
```
nes get-node-ttl all
```
Führe den folgenden Befehl aus, um die TTL für den Zustand fail festzulegen. Ersetze MINUTES durch die Anzahl der Minuten, die für Fehler verwendet werden sollen.
Shell
```
nes set-node-ttl fail MINUTES
```
```
nes set-node-ttl fail MINUTES
```
Führe den folgenden Befehl aus, um die TTL für den Zustand warn festzulegen. Ersetze MINUTES durch die Anzahl der Minuten, die für Warnungen verwendet werden sollen.
Shell
```
nes set-node-ttl warn MINUTES
```
```
nes set-node-ttl warn MINUTES
```

Verwalten, ob Node Eligibility Service ein Knoten offline geschaltet werden kann

Stellt standardmäßig Warnungen bereit, Node Eligibility Service um Sie über Änderungen an der Integrität von Clusterknoten zu informieren. Optionalerweise kannst du dem Dienst erlauben, den fehlerhaften Knoten offline zu schalten, wenn festgestellt wird, dass er nicht wieder in den Cluster aufgenommen werden kann.

Wenn ein Knoten offline geschaltet wird, entfernt die Instanz Auftragszuordnungen aus dem Knoten. Wenn der Knoten Datenspeicherdienste ausführt, aktualisiert die Konfiguration, Node Eligibility Service um die Nichtzuverständigung des Knotens zum erneuten Beitreten zum Cluster widerzuspiegeln.

Um zu verwalten, ob Node Eligibility Service ein Knoten und seine Dienste offline ausgeführt werden können, können Sie Zustände für den Knoten konfigurieren adminaction . Wenn sich ein Knoten im approved Zustand befindet, Node Eligibility Service kann der Knoten offline geschaltet werden. Wenn sich ein Knoten im none Zustand befindet, Node Eligibility Service kann der Knoten nicht offline geschaltet werden.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, melden Sie sich per SSH bei einem beliebigen Knoten Ihres Clusters an. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen finden Sie unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Führen Sie einen der folgenden Befehle aus, um zu konfigurieren, ob Node Eligibility Service ein Knoten offline ausgeführt werden kann.
- Führe den folgenden Befehl aus, damit der Dienst automatisch administrative Aktionen ausführen kann, wenn ein Knoten in den Zustand offline übergeht. Ersetze HOSTNAME durch den Hostnamen des Knotens.
  Shell
```
nes set-node-adminaction approved HOSTNAME
```
```
nes set-node-adminaction approved HOSTNAME
```
- Um die Möglichkeit zum Offlineschalten eines Knotens zu widerrufen Node Eligibility Service, führen Sie den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens.
  Shell
```
nes set-node-adminaction none HOSTNAME
```
```
nes set-node-adminaction none HOSTNAME
```

Anzeigen einer Übersicht über die Knotenintegrität

Verwenden Sie eine der folgenden Methoden, um eine Übersicht über die Integrität Ihrer Knoten anzuzeigen Node Eligibility Service.

Verwende SSH für einen beliebigen Knoten im Cluster, und führe dann nes get-cluster-health aus.
Navigieren Sie zur VerwaltungskonsoleSeite "Status". Weitere Informationen finden Sie unter Zugreifen auf die Verwaltungskonsole.

Erneutes Aktivieren eines nicht berechtigten Knotens zum Beitritt zu einem Cluster

Nachdem Node Eligibility Service erkannt wurde, dass ein Knoten die TTL für den fail Zustand überschritten hat, und nachdem der Dienst den Knoten als ineligiblegekennzeichnet hat, aktualisiert der Dienst den Integritätsstatus für den Knoten nicht mehr. Um einen Knoten für das Einführen in einen Cluster erneut zu aktivieren, kannst du den Status ineligible des Knotens entfernen.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, melden Sie sich per SSH bei einem beliebigen Knoten Ihres Clusters an. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen finden Sie unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Führe den folgenden Befehl aus, um den aktuellen adminaction-Status für den Knoten zu überprüfen. Ersetze HOSTNAME durch den Hostnamen des nicht berechtigten Knotens.
Shell
```
nes get-node-adminaction HOSTNAME
```
```
nes get-node-adminaction HOSTNAME
```
Wenn der Status adminaction derzeit auf approved festgelegt ist, ändere ihn in none, indem du den folgenden Befehl ausführst. Ersetze HOSTNAME durch den Hostnamen des nicht berechtigten Knotens.
Shell
```
nes set-node-adminaction none HOSTNAME
```
```
nes set-node-adminaction none HOSTNAME
```
Um sicherzustellen, dass der Knoten fehlerfrei ist, führe den folgenden Befehl aus, und vergewissere dich, dass der Status des Knotens ready lautet.
Shell
```
nomad node status
```
```
nomad node status
```
- Wenn der Status des Knotens ineligible lautet, ändere den Knoten in einen berechtigten Knoten, indem du eine Verbindung mit dem Knoten per SSH herstellst und den folgenden Befehl ausführst.
  Shell
```
nomad node eligibility -enable -self
```
```
nomad node eligibility -enable -self
```
Führen Sie den folgenden Befehl aus, um die Berechtigung des Knotens zu Node Eligibility Serviceaktualisieren. Ersetze HOSTNAME durch den Hostnamen des Knotens.
Shell
```
nes set-node-eligibility eligible HOSTNAME
```
```
nes set-node-eligibility eligible HOSTNAME
```
Warte 30 Sekunden, und überprüfe dann die Integrität des Clusters. Stelle sicher, dass der Zielknoten berechtigt ist, indem du den folgenden Befehl ausführst.
Shell
```
nes get-cluster-health
```
```
nes get-cluster-health
```

Anzeigen von Protokollen für Node Eligibility Service

Sie können Protokolle von Node Eligibility Service einem beliebigen Knoten im Cluster oder vom Knoten anzeigen, auf dem der Dienst ausgeführt wird. Wenn du ein Supportpaket generierst, sind die Protokolle enthalten. Weitere Informationen finden Sie unter Bereitstellen von Daten für GitHub Support.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, melden Sie sich per SSH bei einem beliebigen Knoten Ihres Clusters an. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen finden Sie unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Um Protokolle Node Eligibility Service von einem beliebigen Knoten im Cluster anzuzeigen, führen Sie den folgenden Befehl aus.
Shell
```
nomad alloc logs -job nes
```
```
nomad alloc logs -job nes
```
Alternativ können Sie Protokolle für Node Eligibility Service den Knoten anzeigen, auf dem der Dienst ausgeführt wird. Der Dienst schreibt Protokolle in das „systemd“-Journal.
- Führen Sie den folgenden Befehl aus, um zu bestimmen, welcher Knoten ausgeführt wird Node Eligibility Service.
  Shell
```
nomad job status "nes" | grep running | grep "${nomad_node_id}" | awk 'NR==2{ print $1 }' | xargs nomad alloc status | grep "Node Name"
```
```
nomad job status "nes" | grep running | grep "${nomad_node_id}" | awk 'NR==2{ print $1 }' | xargs nomad alloc status | grep "Node Name"
```
- Um Protokolle auf dem Knoten anzuzeigen, stelle über SSH eine Verbindung mit dem Knoten her, und führe dann den folgenden Befehl aus.
  Shell
```
journalctl -t nes
```
```
journalctl -t nes
```

Weiterführende Lektüre

Befehlszeilenwerkzeuge