Ü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 mehr 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.

Du kannst die Auswirkungen einer reduzierten Knotenverfügbarkeit proaktiv minimieren, indem du Node Eligibility Service verwendest. 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 kannst du Node Eligibility Service erlauben, nicht berechtigte Knoten offline zu schalten.

Standardmäßig ist Node Eligibility Service deaktiviert. Wenn du Node Eligibility Service aktivierst, wirst du von deiner Instanz vor fehlerhaften Knoten gewarnt, indem ein Banner auf der Administrator-Webbenutzeroberfläche für GitHub Enterprise Server und in der CLI-Ausgabe für einige clusterbezogene Hilfsprogramme angezeigt wird, für z. B. ghe-config-apply und ghe-cluster-diagnostics.

Mit Node Eligibility Service kannst du die Integrität einzelner Knoten überwachen. Außerdem kannst du die allgemeine Integrität deines Clusters überwachen. Weitere Informationen findest du unter Überwachen der Integrität deines Clusters.

Informationen zu Integrität und Berechtigung von Clusterknoten

Um zu bestimmen, ob eine Warnung ausgegeben oder die Konfiguration deines Clusters automatisch angepasst werden soll, wird die Integrität aller Knoten kontinuierlich von Node Eligibility Service überwacht. Jeder Knoten meldet regelmäßig einen Integritätszustand mit Zeitstempel, der von Node Eligibility Service mit einer Gültigkeitsdauer (Time To Live, TTL) vergleicht.

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

Integrität bezieht sich auf die Zugänglichkeit des Knotens innerhalb des Clusters und weist drei mögliche Zustände auf: 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.

Für jeden Knoten bestimmt Node Eligibility Service auf folgende Arten die Integrität und Berechtigung für den Cluster.

Wenn festgestellt wurde, dass ein Knoten fehlerfrei ist, lautet der Integritätszustand healthy und der Berechtigungsstatus eligible.
Wenn festgestellt wurde, dass ein Knoten länger als die warn-TTL einen Fehler aufgewiesen hat, lautet der Integritätszustand warning und der Berechtigungsstatus eligible.
Wenn festgestellt wurde, dass ein Knoten länger als die fail-TTL einen Fehler aufgewiesen hat, lautet sein Integritätszustand critical und sein Berechtigungsstatus ineligible.

Aktivieren von Node Eligibility Service für deinen Cluster

Standardmäßig ist Node Eligibility Service deaktiviert. Du kannst Node Eligibility Service aktivieren, indem du den Wert für app.nes.enabled mit ghe-config festlegst.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, stelle eine SSH-Verbindung mit einem beliebigen Knoten deines Clusters her. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen findest du unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Führe den folgenden Befehl aus, um zu überprüfen, ob Node Eligibility Service derzeit aktiviert ist.
Shell
```
ghe-config app.nes.enabled
```
```
ghe-config app.nes.enabled
```
Führe den folgenden Befehl aus, um Node Eligibility Service zu aktivieren.
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
```
Warte auf den Abschluss der Konfigurationsausführung.
Führe auf einem beliebigen Knoten den folgenden Befehl aus, um zu überprüfen, dass Node Eligibility Service ausgeführt wird.
Shell
```
nomad status nes
```
```
nomad status nes
```

Konfigurieren von TTL-Einstellungen für Node Eligibility Service

Um zu bestimmen, wie Node Eligibility Service dich benachrichtigt, kannst du TTL-Einstellungen für die Zustände fail und warn 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, stelle eine SSH-Verbindung mit einem beliebigen Knoten deines Clusters her. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen findest du 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 einen Knoten offline schalten kann

Standardmäßig stellt Node Eligibility Service Warnungen bereit, um dich über Änderungen der Integrität von Clusterknoten zu benachrichtigen. Wenn durch den Dienst festgestellt wird, dass ein fehlerhafter Knoten nicht wieder in den Cluster eingeführt werden kann, kannst du dem Dienst erlauben, den Knoten offline zu schalten.

Wenn ein Knoten offline geschaltet wird, entfernt die Instanz Auftragszuordnungen aus dem Knoten. Wenn auf dem Knoten Datenspeicherdienste ausgeführt werden, wird die Konfiguration durch Node Eligibility Service aktualisiert, um widerzuspiegeln, dass der Knoten nicht wieder in den Cluster eingeführt werden kann.

Um zu verwalten, ob Node Eligibility Service einen Knoten und seine Dienste offline schalten kann, kannst du adminaction-Zustände für den Knoten konfigurieren. Wenn sich ein Knoten im Zustand approved befindet, kann Node Eligibility Service den Knoten offline schalten. Wenn sich ein Knoten im Zustand none befindet, kann Node Eligibility Service den Knoten nicht offline schalten.

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, stelle eine SSH-Verbindung mit einem beliebigen Knoten deines Clusters her. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen findest du unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Führe einen der folgenden Befehle aus, um zu konfigurieren, ob Node Eligibility Service einen Knoten offline schalten 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
```
- Führe den folgenden Befehl aus, damit Node Eligibility Service Knoten nicht mehr offline schalten kann. 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

Verwende eine der folgenden Methoden, um eine Übersicht über die Integrität deiner Knoten mithilfe von Node Eligibility Service anzuzeigen.

Verwende SSH für einen beliebigen Knoten im Cluster, und führe dann nes get-cluster-health aus.
Navigiere zur Seite "Status" von Verwaltungskonsole. Weitere Informationen findest du unter Zugreifen auf die Verwaltungskonsole.

Erneutes Aktivieren eines nicht berechtigten Knotens für das Einführen in einen Cluster

Nachdem Node Eligibility Service erkannt hat, dass ein Knoten die TTL für den Status fail überschritten und nachdem der Dienst den Knoten als ineligible markiert 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, stelle eine SSH-Verbindung mit einem beliebigen Knoten deines Clusters her. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen findest du 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ühre den folgenden Befehl aus, um die Berechtigung des Knotens in Node Eligibility Service zu aktualisieren. 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 von Node Eligibility Service

Du kannst Protokolle von Node Eligibility Service von einem beliebigen Knoten im Cluster oder von dem Knoten anzeigen, auf dem der Dienst ausgeführt wird. Wenn du ein Supportpaket generierst, sind die Protokolle enthalten. Weitere Informationen findest du unter Providing data to GitHub Support (Bereitstellen von Daten für GitHub Support).

Um eine Verbindung mit Ihre GitHub Enterprise Server-Instance herzustellen, stelle eine SSH-Verbindung mit einem beliebigen Knoten deines Clusters her. Führe auf deiner Arbeitsstation den folgenden Befehl aus. Ersetze HOSTNAME durch den Hostnamen des Knotens. Weitere Informationen findest du unter Auf die Verwaltungsshell (SSH) zugreifen.
Shell
```
ssh -p 122 admin@HOSTNAME
```
```
ssh -p 122 admin@HOSTNAME
```
Um Protokolle von Node Eligibility Service von einem beliebigen Knoten im Cluster anzuzeigen, führe den folgenden Befehl aus.
Shell
```
nomad alloc logs -job nes
```
```
nomad alloc logs -job nes
```
Alternativ kannst du Protokolle von Node Eligibility Service auf dem Knoten anzeigen, auf dem der Dienst ausgeführt wird. Der Dienst schreibt Protokolle in das Journal systemd.
- Führe den folgenden Befehl aus, um zu ermitteln, auf welchem Knoten Node Eligibility Service ausgeführt wird.
  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
```

Weitere Informationsquellen

Befehlszeilenprogramme