"`, bedeutet dies, dass die Signatur erfolgreich verifiziert wurde und Sie mit der Ausführung des EC2 Rescue for Linux-Installationsskripts fortfahren können.
Wenn die Ausgabe die Bezeichnung `BAD signature`enthält, überprüfen Sie, ob Sie das Verfahren korrekt durchgeführt haben. Wenn Sie diese Antwort weiterhin erhalten, kontaktieren Sie Amazon Web Services und führen Sie die Installationsdatei, die Sie zuvor heruntergeladen haben, nicht aus.
Im Folgenden finden Sie Details zu den Warnungen, die möglicherweise angezeigt werden:
+ **WARNING: This key is not certified with a trusted signature\$1 There is no indication that the signature belongs to the owner.**Dies bezieht sich auf Ihr persönliches Vertrauen in Ihre Überzeugung, dass Sie einen authentischen öffentlichen Schlüssel für EC2 Rescue for Linux besitzen. In einer idealen Welt würden Sie ein Amazon Web Services-Büro aufsuchen und den Schlüssel persönlich erhalten. Doch häufiger laden Sie ihn von einer Website herunter. In diesem Fall handelt es sich bei der Website um eine Amazon Web Services-Website.
+ **gpg2: no ultimately trusted keys found.** Dies bedeutet, dass der bestimmte Schlüssel nicht "endgültig vertrauenswürdig" für Sie oder für andere Personen ist, denen Sie vertrauen.
Weitere Informationen finden Sie unter [https://www.gnupg.org/](https://www.gnupg.org/).
# EC2Rescue auf einer Amazon-EC2-Linux-Instance ausführen
EC2Rescue ist ein Befehlszeilentool. Nachdem Sie EC2 Rescue auf Ihrer Linux-Instance installiert haben, erhalten Sie allgemeine Hilfe zur Verwendung des Tools, indem Sie den Befehl ausführen`./ec2rl help`. Sie können sich die verfügbaren Module ansehen, indem Sie `./ec2rl list` ausführen. Sie können Hilfe zu einem bestimmten Modul erhalten, indem Sie `./ec2rl help module_name` ausführen.
Die folgenden Aufgaben können Sie als erste Schritte mit diesem Tool durchführen.
**Topics**
+ [Führen Sie EC2 Rescue-Module aus](#ec2rl_running_module)
+ [Laden Sie die Ergebnisse des EC2 Rescue-Moduls hoch](#ec2rl_uploading_results)
+ [Erstellen von Backups einer Amazon-EC2-Linux-Instance](#ec2rl_creating_backups)
## Führen Sie EC2 Rescue-Module aus
**Um alle EC2 Rescue-Module auszuführen**
Verwenden Sie den Befehl **./ec2rl run** ohne Angabe von Parametern oder Filtern. Einige Module erfordern Root-Zugriff. Falls Sie kein Root-Benutzer sind, verwenden Sie **sudo**, wenn Sie den Befehl ausführen.
```
./ec2rl run
```
**Um ein bestimmtes EC2 Rescue-Modul auszuführen**
Verwenden Sie den **./ec2rl run**-Befehl und geben Sie für `--only-modules` den Namen des Moduls an, das ausgeführt werden soll. Einige Module benötigen *Argumente*, um sie zu verwenden.
```
./ec2rl run --only-modules=module_name --arguments
```
Verwenden Sie beispielsweise den folgenden Befehl, um das **dig**-Modul zur Abfrage der `amazon.com`-Domain auszuführen.
```
./ec2rl run --only-modules=dig --domain=amazon.com
```
**Um die Ergebnisse eines EC2 Rescue-Moduls anzuzeigen**
Führen Sie das Modul aus und zeigen Sie dann die Protokolldatei in `cat /var/tmp/ec2rl/logfile_location` an. Die Protokolldatei für das **dig**-Modul befindet sich beispielsweise im folgenden Verzeichnis:
```
cat /var/tmp/ec2rl/timestamp/mod_out/run/dig.log
```
## Laden Sie die Ergebnisse des EC2 Rescue-Moduls hoch
Wenn Support die Ergebnisse für ein EC2 Rescue-Modul angefordert wurden, können Sie die Protokolldatei mit dem EC2 Rescue-Tool hochladen. Sie können die Ergebnisse entweder an einen von Ihnen bereitgestellten Speicherort Support oder in einen Amazon S3 S3-Bucket hochladen, den Sie besitzen.
**Um Ergebnisse an einen Speicherort hochzuladen, der bereitgestellt wird von Support**
Verwenden Sie den Befehl **./ec2rl upload**. Geben Sie für `--upload-directory` den Speicherort der Protokolldatei an. Geben Sie für `--support-url` die URL an, die von Support bereitgestellt wurde.
```
./ec2rl upload --upload-directory=/var/tmp/ec2rl/logfile_location --support-url="url_provided_by_aws_support"
```
**So laden Sie Ergebnisse in einen Amazon-S3-Bucket hoch**
Verwenden Sie den Befehl **./ec2rl upload**. Geben Sie für `--upload-directory` den Speicherort der Protokolldatei an. Geben Sie für `--presigned-url` eine vorsignierte URL für den S3-Bucket an. Weitere Informationen zum Generieren von vorsignierten Objekten URLs für Amazon S3 finden Sie unter [Objekte mithilfe von vorsignierten Objekten hochladen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html). URLs
```
./ec2rl upload --upload-directory=/var/tmp/ec2rl/logfile_location --presigned-url="presigned_s3_url"
```
## Erstellen von Backups einer Amazon-EC2-Linux-Instance
Sie können EC2 Rescue verwenden, um Ihre Linux-Instance zu sichern, indem Sie ein AMI oder Snapshots der angehängten Volumes erstellen.
**So erstellen Sie ein AMI**
Verwenden Sie den `./ec2rl run`-Befehl und geben Sie für `backup` `ami` an.
```
./ec2rl run --backup=ami
```
**So erstellen Sie Multi-Volume-Snapshots aller angefügten Volumes**
Verwenden Sie den `./ec2rl run`-Befehl und geben Sie für `backup` `allvolumes` an.
```
./ec2rl run --backup=allvolumes
```
**So erstellen Sie einen Snapshot eines bestimmten angefügten Volumes**
Verwenden Sie den `./ec2rl run`-Befehl und geben Sie für `backup` die ID des Volumes an, das gesichert werden soll.
```
./ec2rl run --backup=vol-01234567890abcdef
```
# EC2Rescue-Module für Amazon-EC2-Linux-Instances entwickeln
Module werden in YAML geschrieben, einem Datenserialisierungsstandard. Die YAML-Datei für ein Modul besteht aus einem einzigen Dokument für die Beschreibung des Moduls und seiner Attribute.
## Hinzufüge von Modulattributen
In der folgenden Tabelle werden die verfügbaren Modulattribute aufgeführt.
| Attribut | Beschreibung |
| --- | --- |
| name | Der Name des Moduls. Die Länge des Namens sollte höchstens 18 Zeichen betragen. |
| Version | Die Versionsnummer des Moduls |
| Titel | Eine kurze, aussagekräftige Beschreibung des Moduls. Die Länge dieses Werts sollte höchstens 50 Zeichen betragen. |
| helptext | Die ausführliche Beschreibung des Moduls. Die Länge jeder Zeile sollte höchstens 75 Zeichen betragen. Wenn das Modul mit (obligatorischen oder optionalen) Argumenten aufgerufen wird, sollten sie in dem helptext-Wert einhalten sein. Beispiel: helptext: !!str |
Collect output from ps for system analysis
Consumes --times= for number of times to repeat
Consumes --period= for time period between repetition
|
| placement | Die Stufe, in der das Modul ausgeführt werden sollte. Unterstützte Werte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| language | Die Sprache, in der das Modul geschrieben wurde. Unterstützte Werte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) Python-Code muss sowohl mit Python 2.7.9\$1 als auch mit Python 3.2\$1 kompatibel sein. |
| remediation | Zeit an, ob das Modul eine Problembehebung unterstützt. Unterstützte Werte sind `True` oder `False`. Das Modul ist standardmäßig `False`, wenn diese Angabe fehlt, womit sie zu einem optionalen Attribut für Module wird, die keine Problembehebung unterstützen. |
| content | Der gesamte Code für das Skript. |
| constraint | Der Name des Objekts, das Werte für die Beschränkung enthält. |
| Domain | Eine Beschreibung, wie das Modul gruppiert oder klassifiziert wird. Die enthaltenen Module verwenden die folgenden Bereiche: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| class | Eine Beschreibung der Aufgabe, die von dem Modul durchgeführt wird. Die enthaltenen Module verwenden die folgenden Klassen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| distro | Die Liste der Linux-Distributionen, die dieses Modul unterstützt. Die enthaltenen Module verwenden die folgenden Distributionen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| Erforderlich | Die obligatorischen Argumente für den Aufruf des Moduls mit dem CLI. |
| optional | Die optionalen Argumente für den Aufruf des Moduls. |
| software | Die ausführbare Software, die in dem Modul verwendet wird. Dieses Attribut dient der Spezifikation von Software, die nicht standardmäßig installiert ist. Die Logik von EC2 Rescue for Linux stellt sicher, dass diese Programme vorhanden und ausführbar sind, bevor das Modul ausgeführt wird. |
| package | Das Quellcode-Paket für eine ausführbare Software. Dieses Attribut dient der Spezifikation ausführlicher Details zu dem Softwarepaket, einschließlich einer URL, unter der weitere Informationen heruntergeladen oder abgerufen werden können. |
| sudo | Zeigt an, ob für die Ausführung des Moduls Root-Berechtigungen erforderlich sind. Sie müssen keine sudo-Checks in dem Skript für das Modul implementieren. Wenn der Wert true ist, führt die EC2 Rescue for Linux-Logik das Modul nur aus, wenn der ausführende Benutzer Root-Zugriff hat. |
| perfimpact | Zeigt an, ob das Modul signifikante Auswirkungen auf die Leistung in der Umgebung haben kann, in der es ausgeführt wird. Wenn dieser Wert auf „true” gesetzt und das `--perfimpact=true`-Argument nicht aufgerufen wird, dann wird das Modul übersprungen. |
| parallelexclusive | Spezifiziert ein Programm, dass gegenseitige Exklusivität erfordert. So können z. B. alle Module, für die hier „bpf” angegeben wird, nur nacheinander ausgeführt werden. |
## Hinzufügen von Umgebungsvariablen
In der folgenden Tabelle werden die verfügbaren Umgebungsvariablen aufgeführt.
| Umgebungsvariable | Beschreibung |
| --- | --- |
| `EC2RL_CALLPATH` | Der Pfad zu ec2rl.py. Anhand dieses Pfades können Sie das Lib-Verzeichnis finden und von Anbietern bereitgestellte Python-Module benutzen. |
| `EC2RL_WORKDIR` | Das primäre temporäre Verzeichnis für das Diagnosetool Standardwer: `/var/tmp/ec2rl`. |
| `EC2RL_RUNDIR` | Das Verzeichnis, in dem alle Ausgaben gespeichert werden Standardwer: `/var/tmp/ec2rl/`. |
| `EC2RL_GATHEREDDIR` | Das Stammverzeichnis für die erfassten Moduldaten Standardwer:`/var/tmp/ec2rl//mod_out/gathered/`. |
| `EC2RL_NET_DRIVER` | Der Treiber für die erste, alphabetisch sortierte, nicht virtuelle Netzwerkschnittstelle in der Instance Beispiele: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| `EC2RL_SUDO` | Wahr, wenn EC2 Rescue for Linux als Root-Benutzer ausgeführt wird; andernfalls False. |
| `EC2RL_VIRT_TYPE` | Der Virtualisierungstyp gemäß der bereitgestellten Instance-Metadaten Beispiele: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| `EC2RL_INTERFACES` | Eine nummerierte List der Schnittstellen in dem System. Der Wert besteht aus einer Zeichenfolge, die Namen wie `eth0`, `eth1` usw. enthält. Er wird über `functions.bash` generiert und ist nur für Module verfügbar, die diese aufgerufen haben. |
## Verwenden des YAML-Syntax
Beachten Sie unbedingt die folgenden Punkte, wenn Sie die YAML-Dateien für ein Modul erstellen:
+ Drei Bindestriche hintereinander (`---`) zeigen den Beginn eines Dokuments explizit an.
+ Der Tag `!ec2rlcore.module.Module` zeigt dem YAML-Parser an, welcher Konstruktor aufgerufen werden soll, um das Objekt aus dem Datenstrom zu erstellen. Sie finden den Konstruktor in der Datei `module.py`.
+ Der Tag `!!str` weist den YAML-Parser an, keinen Versuch zur Bestimmung des Datentyps zu unternehmen, sondern den Inhalt als Zeichenfolgeliteral zu interpretieren.
+ Das Pipe-Zeichen (`|`) zeigt dem YAML-Parser an, dass es sich um einen skalaren Wert handelt – ähnlich einem Literal. In diesem Fall übernimmt der Parser alle Leerraumzeichen. Dies ist im Zusammenhang mit Modulen sehr wichtig, da Einrückungen und Zeilenumbrüche erhalten bleiben.
+ Die Standardeinrückung in YAML besteht aus zwei Leerzeichen, wie in den folgenden Beispielen gezeigt. Stellen Sie sicher, dass Sie in Ihrem Skript mit den jeweiligen Standard-Einrückungen arbeiten (z. B. vier Leerzeichen in Python) und den gesamten Inhalt anschließend in der Moduldatei um zwei Leerzeichen einrücken.
## Beispielmodule
Beispiel 1 (`mod.d/ps.yaml`):
```
--- !ec2rlcore.module.Module
# Module document. Translates directly into an almost-complete Module object
name: !!str ps
path: !!str
version: !!str 1.0
title: !!str Collect output from ps for system analysis
helptext: !!str |
Collect output from ps for system analysis
Requires --times= for number of times to repeat
Requires --period= for time period between repetition
placement: !!str run
package:
- !!str
language: !!str bash
content: !!str |
#!/bin/bash
error_trap()
{
printf "%0.s=" {1..80}
echo -e "\nERROR: "$BASH_COMMAND" exited with an error on line ${BASH_LINENO[0]}"
exit 0
}
trap error_trap ERR
# read-in shared function
source functions.bash
echo "I will collect ps output from this $EC2RL_DISTRO box for $times times every $period seconds."
for i in $(seq 1 $times); do
ps auxww
sleep $period
done
constraint:
requires_ec2: !!str False
domain: !!str performance
class: !!str collect
distro: !!str alami ubuntu rhel suse
required: !!str period times
optional: !!str
software: !!str
sudo: !!str False
perfimpact: !!str False
parallelexclusive: !!str
```
# Problembehebung einer beeinträchtigten Amazon EC2 EC2-Windows-Instance mithilfe von Rescue EC2
EC2Rescue for Windows Server ist ein easy-to-use Tool, das Sie auf einer Amazon EC2 Windows Server-Instance ausführen, um mögliche Probleme zu diagnostizieren und zu beheben. Das Tool ist nützlich zum Sammeln von Protokolldateien, zur Behebung von Problemen und zur proaktiven Suche nach möglichen Problembereichen. Es kann sogar Amazon EBS-Stamm-Volumes von anderen Instances untersuchen und relevante Protokolle zur Fehlerbehebung bei Windows-Server-Instances mithilfe des entsprechenden Volumes erfassen. Im Folgenden sind einige häufig auftretende Probleme aufgeführt, die EC2 Rescue beheben kann:
+ Verbindungsprobleme mit Instances aufgrund der Konfigurationen der Firewall, des Remote Desktop Protocol (RDP) oder der Netzwerkschnittstelle
+ Probleme beim Starten des Betriebssystems aufgrund eines Stoppfehlers, einer Startschleife oder einer beschädigten Registrierung
+ Probleme, für die möglicherweise eine erweiterte Protokollanalyse und Fehlerbehebung erforderlich ist
EC2Rescue für Windows Server besteht aus zwei verschiedenen Modulen:
+ Ein **Datensammelmodul**, das Daten aus allen verschiedenen Quellen sammelt
+ Ein **Analysemodul**, das die gesammelten Daten nach einer Reihe vordefinierter Regeln analysiert, um Probleme zu erfassen und Vorschläge zu unterbreiten
Das Tool EC2Rescue für Windows Server wird nur auf Amazon-EC2-Instances unter Windows Server 2012 oder höher ausgeführt. Wenn das Tool startet, überprüft es, ob es auf einer Amazon EC2 Instance ausgeführt wird.
**Anmerkung**
Das `AWSSupport-ExecuteEC2Rescue` AWS Systems Manager Automation-Runbook verwendet das EC2Rescue-Tool, um allgemeine Verbindungsprobleme mit der angegebenen EC2-Instance zu beheben und, sofern möglich, zu beheben. [Weitere Informationen und Informationen zum Ausführen dieser Automatisierung finden Sie unter > 2Rescue. AWSSupport-ExecuteEC](https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awssupport-executeec2rescue.html)
Wenn Sie eine Linux-Instance verwenden, siehe [Problembehebung einer beeinträchtigten Amazon EC2 EC2-Linux-Instance mithilfe von Rescue EC2](Linux-Server-EC2Rescue.md).
**Topics**
+ [Problembehandlung mithilfe der EC2 Rescue-GUI](ec2rw-gui.md)
+ [Problembehandlung mit EC2 Rescue CLI](ec2rw-cli.md)
+ [Problembehandlung mit EC2 Rescue und Systems Manager](ec2rw-ssm.md)
# Beheben Sie eine beeinträchtigte Windows-Instanz mit der EC2 Rescue-GUI
EC2Rescue for Windows Server kann die folgenden Analysen auf **Offline-Instanzen** durchführen:
| Option | Beschreibung |
| --- | --- |
| Diagnose und Datenrettung | EC2Rescue for Windows Server kann Probleme mit den folgenden Diensteinstellungen erkennen und beheben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) |
| Wiederherstellen | Durchführen einer der folgenden Aktionen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-gui.html) |
| Erfassen von Protokollen | Erlaubt das Erfassen von Protokollen in der Instance zur Analyse. |
EC2Rescue for Windows Server kann die folgenden Daten von **aktiven und Offline-Instanzen** sammeln:
| Item | Beschreibung |
| --- | --- |
| Ereignisprotokoll | Sammelt Anwendungs-, System- und EC2 Konfigurationsereignisprotokolle. |
| Registrierung | Sammelt SYSTEM- und SOFTWARE-Hives. |
| Windows-Aktualisierungsprotokoll | Sammelt vom Windows Update generierte Protokolldateien. In Windows Server 2016 und höher wird das Protokoll im Format Ereignisablaufverfolgung für Windows (ETW) gesammelt. |
| Sysprep-Protokoll | Sammelt vom Windows-Systemvorbereitungs-Tool generierte Protokolldateien. |
| Driver-Setup-Protokoll | Sammelt Windows-SetupAPI-Protokolle (setupapi.dev.log und setupapi.setup.log). |
| Boot-Konfiguration | Sammelt HKEY\$1LOCAL\$1MACHINE\$1BCD00000000-Hive. |
| Speicherabbild | Sammelt alle existierenden Speicherabbilddateien in der Instance. |
| EC2Config-Datei | Sammelt vom EC2 Config-Dienst generierte Protokolldateien. |
| EC2Datei starten | Sammelt Protokolldateien, die von den EC2 Launch-Skripten generiert wurden. |
| SSM-Agent-Datei | Sammelt vom SSM-Agenten generierte Protokolldateien und Patch-Manager-Protokolle. |
| Elastische EC2-Datei GPUs | Sammelt Ereignisprotokolle im Zusammenhang mit Elastic GPUs. |
| ECS | Sammelt Protokolle im Zusammenhang mit Amazon ECS. |
| CloudEndure | Sammelt Protokolldateien, die sich auf CloudEndure Agent beziehen. |
| AWS Replication Agent für MGN- oder DRS-Protokolldateien | Sammelt Protokolldateien, die sich auf AWS Application Migration Service oder AWS Elastic Disaster Recovery beziehen. |
EC2Rescue for Windows Server kann die folgenden zusätzlichen Daten von **aktiven Instanzen** sammeln:
| Item | Beschreibung |
| --- | --- |
| Systeminformationen | Sammelt MSInfo32. |
| Ergebnis der Gruppenrichtlinie | Erfasst einen Bericht zu einer Gruppenrichtlinie. |
## Analysieren einer Offline-Instance
Die **Offline Instance**-Option ist nützlich zur Fehlerbehebung von Startproblemen bei Windows-Instances.
**So führen Sie eine Aktion bei einer Offline-Instance aus**
1. Laden Sie das [EC2Rescue for Windows Server-Tool von einer funktionierenden Windows Server-Instanz](https://s3.amazonaws.com/ec2rescue/windows/EC2Rescue_latest.zip?x-download-source=docs) herunter und extrahieren Sie die Dateien.
Sie können den folgenden PowerShell Befehl ausführen, um EC2 Rescue herunterzuladen, ohne Ihre verstärkte Sicherheitskonfiguration (ESC) für Internet Explorer zu ändern:
```
Invoke-WebRequest https://s3.amazonaws.com/ec2rescue/windows/EC2Rescue_latest.zip -OutFile $env:USERPROFILE\Desktop\EC2Rescue_latest.zip
```
Mit diesem Befehl wird die EC2 Rescue-ZIP-Datei auf den Desktop des aktuell angemeldeten Benutzers heruntergeladen.
**Anmerkung**
Wenn beim Herunterladen der Datei eine Fehlermeldung angezeigt wird und Sie Windows Server 2016 oder eine frühere Version verwenden, muss TLS 1.2 möglicherweise für Ihr PowerShell Terminal aktiviert werden. Sie können TLS 1.2 für die aktuelle PowerShell Sitzung mit dem folgenden Befehl aktivieren und es dann erneut versuchen:
```
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
```
1. Halten Sie die fehlerhafte Instance an, falls Sie das noch nicht getan haben.
1. Trennen Sie das EBS-Root-Volume von der fehlerhaften Instance und fügen Sie das Volume einer funktionierenden Windows-Instance hinzu, auf der EC2 Rescue for Windows Server installiert ist.
1. Führen Sie das EC2 Rescue for Windows Server-Tool auf der funktionierenden Instanz aus und wählen Sie **Offline-Instanz**.
1. Wählen Sie die Festplatte mit dem neu gemounteten Volume und anschließend **Next** aus.
1. Bestätigen Sie die Festplattenauswahl und wählen Sie **Yes** aus.
1. Wählen Sie die Offline-Instance-Option zur Durchführung und anschließend **Next** aus.
Das Tool EC2 Rescue for Windows Server scannt das Volume und sammelt Informationen zur Fehlerbehebung auf der Grundlage der ausgewählten Protokolldateien.
## Sammeln von Daten aus einer aktiven Instance
Sie können Protokolle und andere Daten aus einer aktiven Instance sammeln.
**So sammeln Sie Daten aus einer aktiven Instance**
1. Herstellen einer Verbindung mit Ihrer Windows-Instance.
1. Laden Sie das [EC2Rescue for Windows Server-Tool](https://s3.amazonaws.com/ec2rescue/windows/EC2Rescue_latest.zip?x-download-source=docs) auf Ihre Windows-Instanz herunter und extrahieren Sie die Dateien.
Sie können den folgenden PowerShell Befehl ausführen, um EC2 Rescue herunterzuladen, ohne Ihre verstärkte Sicherheitskonfiguration (ESC) für Internet Explorer zu ändern:
```
Invoke-WebRequest https://s3.amazonaws.com/ec2rescue/windows/EC2Rescue_latest.zip -OutFile $env:USERPROFILE\Desktop\EC2Rescue_latest.zip
```
Mit diesem Befehl wird die EC2 Rescue-ZIP-Datei auf den Desktop des aktuell angemeldeten Benutzers heruntergeladen.
**Anmerkung**
Wenn beim Herunterladen der Datei eine Fehlermeldung angezeigt wird und Sie Windows Server 2016 oder eine frühere Version verwenden, muss TLS 1.2 möglicherweise für Ihr PowerShell Terminal aktiviert werden. Sie können TLS 1.2 für die aktuelle PowerShell Sitzung mit dem folgenden Befehl aktivieren und es dann erneut versuchen:
```
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
```
1. Öffnen Sie die Anwendung EC2 Rescue for Windows Server und akzeptieren Sie die Lizenzvereinbarung.
1. Wählen Sie **Next**, **Current instance**, **Capture logs**.
1. Wählen Sie die Datenelemente, die gesammelt werden sollen, und anschließend **Collect...** aus. Lesen Sie den Warnhinweis, und wählen Sie zum Fortfahren **Yes** aus.
1. Wählen Sie einen Dateinamen und einen Speicherort für die ZIP-Datei und anschließend **Save** aus.
1. Nachdem EC2 Rescue for Windows Server den Vorgang abgeschlossen hat, wählen Sie „**Übergeordneten Ordner öffnen“**, um die ZIP-Datei anzuzeigen.
1. Wählen Sie **Finish** (Abschließen).
# Beheben Sie eine beeinträchtigte Windows-Instanz mit der EC2 Rescue-CLI
Mit der Befehlszeilenschnittstelle (CLI) von EC2 Rescue for Windows Server können Sie ein EC2 Rescue for Windows Server-Plug-In (als „Aktion“ bezeichnet) programmgesteuert ausführen.
Das Tool EC2 Rescue für Windows Server verfügt über zwei Ausführungsmodi:
+ **/online** — Auf diese Weise können Sie auf der Instanz, auf der EC2 Rescue for Windows Server installiert ist, Aktionen ausführen, z. B. Protokolldateien sammeln.
+ **/offline:** —Auf diese Weise können Sie Aktionen auf dem Offline-Root-Volume ausführen, das an eine separate Amazon EC2 EC2-Windows-Instance angehängt ist, auf der Sie EC2 Rescue for Windows Server installiert haben.
Laden Sie das Tool [EC2Rescue for Windows Server EC2](https://s3.amazonaws.com/ec2rescue/windows/EC2Rescue_latest.zip?x-download-source=docs) auf Ihre Windows-Instance herunter und extrahieren Sie die Dateien. Sie können die Hilfedatei mit dem folgenden Befehl anzeigen:
```
EC2RescueCmd.exe /help
```
EC2Rescue for Windows Server kann die folgenden Aktionen in einer Amazon EC2-Windows-Instance ausführen:
+ [Erfassen-Aktion](#ec2rw-collect)
+ [Rettungsaktion](#ec2rw-rescue)
+ [Wiederherstellen-Aktion](#ec2rw-restore)
## Erfassen-Aktion
**Anmerkung**
Sie können alle Protokolle, eine ganze Protokollgruppe oder ein einzelnes Protokoll in einer Gruppe erfassen.
EC2Rescue for Windows Server kann die folgenden Daten von **aktiven und Offline-Instanzen** sammeln.
| Gruppe protokollieren | Verfügbare Protokolle | Beschreibung |
| --- | --- | --- |
| all | | Erfasst alle verfügbaren Protokolle. |
| eventlog | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt Anwendungs-, System- und EC2 Konfigurationsereignisprotokolle. |
| memory-dump | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt alle existierenden Speicherabbilddateien in der Instance. |
| ec2config | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt vom EC2 Config-Dienst generierte Protokolldateien. |
| ec2launch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt Protokolldateien, die von den EC2 Launch-Skripten generiert wurden. |
| ssm-agent | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt vom SSM-Agenten generierte Protokolldateien und Patch-Manager-Protokolle. |
| sysprep | 'Log Files' | Sammelt vom Windows-Systemvorbereitungs-Tool generierte Protokolldateien. |
| driver-setup | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt Windows-SetupAPI-Protokolle (setupapi.dev.log und setupapi.setup.log). |
| registry | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt SYSTEM- und SOFTWARE-Hives. |
| egpu | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt Ereignisprotokolle im Zusammenhang mit Elastic GPUs. |
| boot-config | 'BCDEDIT Output' | Sammelt HKEY\$1LOCAL\$1MACHINE\$1BCD00000000-Hive. |
| windows-update | 'Log Files' | Sammelt vom Windows Update generierte Protokolldateien. In Windows Server 2016 und höher wird das Protokoll im Format Ereignisablaufverfolgung für Windows (ETW) gesammelt. |
| cloudendure | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Sammelt Protokolldateien, die sich auf CloudEndure Agent beziehen. |
EC2Rescue for Windows Server kann die folgenden zusätzlichen Daten von **aktiven Instanzen** sammeln.
| Gruppe protokollieren | Verfügbare Protokolle | Beschreibung |
| --- | --- | --- |
| system-info | 'MSInfo32 Output' | Sammelt MSInfo32. |
| gpresult | 'GPResult Output' | Erfasst einen Bericht zu einer Gruppenrichtlinie. |
Die folgenden Optionen sind verfügbar:
+ **/output: < outputFilePath >** ‐ Erforderlicher Pfad zur Zieldatei, um die gesammelten Protokolldateien im ZIP-Format zu speichern.
+ **/no-offline** – Optionales Attribut, das im Offline-Modus verwendet wird. Setzt das Volume nach Abschluss der Aktion nicht auf offline.
+ **/no-fix-signature**‐ Optionales Attribut, das im Offline-Modus verwendet wird. Korrigiert eine mögliche Datenträger-Signaturkollision nach Abschluss der Aktion nicht.
### Beispiele
Im Folgenden finden Sie Beispiele für die Verwendung der EC2 Rescue for Windows Server-CLI.
#### Beispiele für den Online-Modus
Erfassen aller verfügbaren Protokolle:
```
EC2RescueCmd /accepteula /online /collect:all /output:
```
Erfassen nur einer bestimmten Protokollgruppe:
```
EC2RescueCmd /accepteula /online /collect:ec2config /output:
```
Erfassen einzelner Protokolle in einer Protokollgruppe:
```
EC2RescueCmd /accepteula /online /collect:'ec2config.Log Files,driver-setup.SetupAPI Log Files' /output:
```
#### Beispiele für den Offline-Modus
Erfassen aller verfügbaren Protokolle in einem EBS-Volume. Das Volume wird durch den device\$1id-Wert angegeben.
```
EC2RescueCmd /accepteula /offline:xvdf /collect:all /output:
```
Erfassen nur einer bestimmten Protokollgruppe:
```
EC2RescueCmd /accepteula /offline:xvdf /collect:ec2config /output:
```
## Rettungsaktion
EC2Rescue für Windows Server kann Probleme mit den folgenden Diensteinstellungen erkennen und beheben:
| Servicegruppe | Verfügbare Aktionen | Beschreibung |
| --- | --- | --- |
| all | | |
| system-time | 'RealTimeIsUniversal' | Systemzeit[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) |
| firewall | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Windows-Firewall [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) |
| rdp | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | Remotedesktop [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) |
| ec2config | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) | EC2Config [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) |
| ec2launch | 'Reset Administrator Password' | Generiert ein neues Windows-Administratorpasswort. |
| network | 'DHCP Service Startup' | Netzwerkschnittstelle [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/ec2rw-cli.html) |
Die folgenden Optionen sind verfügbar:
+ **/level:** – Optionales Attribut für die Prüfstufe, die durch die Aktion ausgelöst werden sollte. Die zulässigen Werte lauten: `information`, `warning`, `error`, `all`. Standardmäßig ist der Wert eingestell `error`.
+ **/check-only** – Optionales Attribut, das einen Bericht generiert, aber keine Änderungen am Offline-Volume vornimmt.
**Anmerkung**
Wenn EC2 Rescue for Windows Server eine mögliche Kollision mit der Festplattensignatur erkennt, wird die Signatur standardmäßig nach Abschluss des Offline-Vorgangs korrigiert, auch wenn Sie die `/check-only` Option verwenden. Sie müssen die `/no-fix-signature`-Option verwenden, um die Korrektur zu verhindern.
+ **/no-offline** – Optionales Attribut, das verhindert, dass das Volume nach Abschluss der Aktion auf offline gesetzt wird.
+ **/no-fix-signature**‐ Optionales Attribut, das eine mögliche Kollision mit der Festplattensignatur nach Abschluss der Aktion nicht behebt.
### Beispiele für Rettungen
Im Folgenden finden Sie Beispiele für die Verwendung der EC2 Rescue for Windows Server-CLI. Das Volume wird durch den device\$1id-Wert angegeben.
Der Versuch, alle erkannten Probleme auf einem Volume zu beheben:
```
EC2RescueCmd /accepteula /offline:xvdf /rescue:all
```
Der Versuch, alle Probleme in einer Servicegruppe auf einem Volume zu beheben:
```
EC2RescueCmd /accepteula /offline:xvdf /rescue:firewall
```
Der Versuch, ein bestimmtes Problem in einer Servicegruppe auf einem Volume zu beheben:
```
EC2RescueCmd /accepteula /offline:xvdf /rescue:rdp.'Service Start'
```
Der Versuch, mehrere Probleme anzugeben und auf einem Volume zu beheben:
```
EC2RescueCmd /accepteula /offline:xvdf /rescue:'system-time.RealTimeIsUniversal,ec2config.Service Start'
```
## Wiederherstellen-Aktion
EC2Rescue für Windows Server kann Probleme mit den folgenden Diensteinstellungen erkennen und beheben:
| Servicegruppe | Verfügbare Aktionen | Beschreibung |
| --- | --- | --- |
| Wiederherstellen der letzten bekannten funktionierenden Konfiguration | lkgc | Last Known Good Configuration – Versucht, die Instance im letzten bekannten bootfähigen Zustand zu starten. |
| Wiederherstellen der Windows-Registrierung aus der letzten Sicherung | regback | Restore registry from backup – Stellt die Registrierung aus \$1Windows\$1System32\$1config\$1RegBack wieder her. |
Die folgenden Optionen sind verfügbar:
+ **/no-offline** — Optionales Attribut, das verhindert, dass das Volume nach Abschluss der Aktion auf offline gesetzt wird.
+ **/no-fix-signature**— Optionales Attribut, das eine mögliche Kollision mit der Festplattensignatur nach Abschluss der Aktion nicht behebt.
### Beispiele für Wiederherstellungen
Im Folgenden finden Sie Beispiele für die Verwendung der EC2 Rescue for Windows Server-CLI. Das Volume wird durch den device\$1id-Wert angegeben.
Wiederherstellen der letzten bekannten funktionierenden Konfiguration für ein Volume:
```
EC2RescueCmd /accepteula /offline:xvdf /restore:lkgc
```
Wiederherstellen der letzten Sicherung der Windows-Registrierung eines Volumes:
```
EC2RescueCmd /accepteula /offline:xvdf /restore:regback
```
# Beheben Sie eine beeinträchtigte Windows-Instanz mit EC2 Rescue und Systems Manager
Support stellt Ihnen ein Systems Manager Run Command-Dokument zur Verfügung, das eine Schnittstelle zu Ihrer Systems Manager-fähigen Instanz bildet, um EC2 Rescue für Windows Server auszuführen. Das Run Command-Dokument hat den Namen `AWSSupport-RunEC2RescueForWindowsTool`.
Dieses Systems Manager Run Command-Dokument führt die folgenden Aufgaben aus:
+ Lädt EC2 Rescue für Windows Server herunter und verifiziert es.
+ Importiert ein PowerShell Modul, um Ihnen die Interaktion mit dem Tool zu erleichtern.
+ Läuft EC2 RescueCmd mit dem angegebenen Befehl und den angegebenen Parametern.
Das Systems Manager Run Command-Dokument akzeptiert drei Parameter:
+ **Befehl** — Die Aktion EC2 Rescue for Windows Server. Die aktuell zulässigen Werte sind:
+ **ResetAccess**— Setzt das lokale Administratorkennwort zurück. Das lokale Administratorpasswort der aktuellen Instance wird zurückgesetzt und das zufallsgeneriert Passwort wird in Parameter Store als sicher gespeicher `/EC2Rescue/Password/`. Wenn Sie diese Aktion auswählen und keine Parameter angeben, werden Passwörter automatisch mit dem Standard-Verschlüsselung verschlüsselt. Sie können in den Parametern optional die ID eines Verschlüsselung angeben, um das Passwort mit einem eigenen Schlüssel zu verschlüsseln.
+ **CollectLogs**— Führt EC2 Rescue für Windows Server mit der Aktion aus. `/collect:all` Wenn Sie diese Aktion auswählen, müssen die `Parameters` des Amazon S3-Buckets, auf den die Protokolle hochgeladen werden sollen, in den Logs enthalten sein.
+ **FixAll**— Führt EC2 Rescue für Windows Server mit der Aktion aus`/rescue:all`. Wenn Sie diese Aktion auswählen, muss der Name des zu rettenden Blockgerätes in den `Parameters` enthalten sein.
+ **Parameter** — Die PowerShell Parameter, die für den angegebenen Befehl übergeben werden sollen.
## Voraussetzungen
Um die **ResetAccess**Aktion auszuführen, muss Ihrer Amazon EC2 EC2-Instance eine Richtlinie angehängt sein, die Berechtigungen zum Schreiben des verschlüsselten Passworts in den Parameter Store gewährt. Warten Sie ein paar Minuten, bevor Sie versuchen, das Passwort einer Instance zurückzusetzen, nachdem Sie diese Richtlinie der zugehörigen IAM-Rolle zugeordnet haben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:PutParameter"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:parameter/EC2Rescue/Passwords/"
]
}
]
}
```
------
Wenn Sie einen benutzerdefinierten KMS-Schlüssel und nicht den Standard-KMS-Schlüssel verwenden, verwenden Sie stattdessen diese Richtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:PutParameter"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:parameter/EC2Rescue/Passwords/"
]
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/"
]
}
]
}
```
------
## JSON-Daten für das Dokument anzeigen
Im folgenden Verfahren wird beschrieben, wie Sie die JSON-Daten für diesen Dokument anzeigen können.
**So zeigen Sie die JSON-Daten für das Systems Manager Run Command-Dokument an**
1. Öffnen Sie die AWS Systems Manager Konsole unter. [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)
1. Erweitern Sie im Navigationsbereich die Option **Verwaltungs-Tools ändern** und wählen Sie **Dokumente** aus.
1. Geben Sie `AWSSupport-RunEC2RescueForWindowsTool` in der Suchleiste ein und wählen Sie dann das Dokument `AWSSupport-RunEC2RescueForWindowsTool` aus.
1. Wählen Sie die Registerkarte **Content** aus.
## Beispiele
Im Folgenden finden Sie einige Beispiele zur Verwendung des Systems Manager Manager-Dokuments Run Command zum Ausführen von EC2 Rescue für Windows Server mithilfe von AWS CLI. Weitere Informationen zum Senden von Befehlen mit dem finden Sie AWS CLI unter [send-command](https://docs.aws.amazon.com/cli/latest/reference/ssm/send-command.html).
**Topics**
+ [Der Versuch, alle erkannten Probleme auf einem Offline-Stamm-Volume zu beheben](#ec2rw-ssm-exam1)
+ [Erfassen von Protokollen in der aktuellen Amazon EC2-Windows-Instance](#ec2rw-ssm-exam2)
+ [Zurücksetzen des lokalen Administratorpassworts](#ec2rw-ssm-exam4)
### Der Versuch, alle erkannten Probleme auf einem Offline-Stamm-Volume zu beheben
Versuchen Sie, alle erkannten Probleme auf einem Offline-Stamm-Volume zu beheben, das einer Amazon EC2-Windows-Instance zugeordnet ist:
```
aws ssm send-command --instance-ids "i-0cb2b964d3e14fd9f" --document-name "AWSSupport-RunEC2RescueForWindowsTool" --parameters "Command=FixAll, Parameters='xvdf'" --output text
```
### Erfassen von Protokollen in der aktuellen Amazon EC2-Windows-Instance
Erfassen Sie alle Protokolle von der aktuellen Online- Amazon EC2-Windows-Instance und laden Sie sie in einen Amazon S3-Bucket hoch:
```
aws ssm send-command --instance-ids "i-0cb2b964d3e14fd9f" --document-name "AWSSupport-RunEC2RescueForWindowsTool" --parameters "Command=CollectLogs, Parameters='amzn-s3-demo-bucket'" --output text
```
### Zurücksetzen des lokalen Administratorpassworts
In den folgenden Beispielen werden Methoden gezeigt, mit denen Sie das lokale Administratorpasswort zurücksetzen können. In der Ausgabe wird ein Link zu Parameter Store bereitgestellt, unter dem Sie das sichere, zufallsgenerierte Passwort finden können; mit diesem können Sie anschließend über RDP als lokaler Administrator auf Ihre Amazon EC2-Windows-Instance zugreifen.
Setzen Sie das lokale Administratorkennwort einer Online-Instanz zurück. Verwenden Sie dabei die Standardeinstellung: AWS KMS key alias/aws/ssm
```
aws ssm send-command --instance-ids "i-0cb2b964d3e14fd9f" --document-name "AWSSupport-RunEC2RescueForWindowsTool" --parameters "Command=ResetAccess" --output text
```
Zurücksetzen des lokalen Administratorpassworts für eine Online-Instance mithilfe eines Verschlüsselung:
```
aws ssm send-command --instance-ids "i-0cb2b964d3e14fd9f" --document-name "AWSSupport-RunEC2RescueForWindowsTool" --parameters "Command=ResetAccess, Parameters=a133dc3c-a2g4-4fc6-a873-6c0720104bf0" --output text
```
**Anmerkung**
In diesem Beispiel lautet Verschlüsselung `a133dc3c-a2g4-4fc6-a873-6c0720104bf0`.
# Serielle EC2-Konsole für -Instances
Mit der seriellen EC2-Konsole haben Sie Zugriff auf den seriellen Port Ihrer Amazon EC2-Instance, den Sie zur Behebung von Boot-, Netzwerkkonfigurations- und anderen Problemen verwenden können. Die serielle Konsole erfordert nicht, dass Ihre Instance über Netzwerkfähigkeiten verfügt. Mit der seriellen Konsole können Sie Befehle für eine Instance eingeben, als ob Ihre Tastatur und Ihr Monitor direkt an die serielle Schnittstelle der Instance angeschlossen wären. Die Sitzung der seriellen Konsole dauert während des Neustarts und Stopps der Instance. Während des Neustarts können Sie alle Boot-Meldungen von Anfang an anzeigen.
Der Zugriff auf die serielle Konsole ist standardmäßig nicht verfügbar. Ihre Organisation muss Kontozugriff auf die serielle Konsole gewähren und IAM-Richtlinien konfigurieren, um Ihren Benutzern Zugriff auf die serielle Konsole zu gewähren. Der Zugriff auf serielle Konsolen kann mithilfe von Instanzen IDs, Ressourcen-Tags und anderen IAM-Hebeln detailliert gesteuert werden. Weitere Informationen finden Sie unter [Konfigurieren des Zugriffs auf die serielle EC2-Konsole](configure-access-to-serial-console.md).
Auf die serielle Konsole kann über die EC2-Konsole oder zugegriffen werde AWS CLI.
Die serielle Konsole ist ohne zusätzliche Kosten verfügbar.
**Topics**
+ [Voraussetzungen für die serielle EC2-Konsole](ec2-serial-console-prerequisites.md)
+ [Konfigurieren des Zugriffs auf die serielle EC2-Konsole](configure-access-to-serial-console.md)
+ [Herstellen einer Verbindung zur seriellen EC2-Konsole](connect-to-serial-console.md)
+ [Trennen der Verbindung mit der seriellen EC2-Konsole](disconnect-serial-console-session.md)
+ [Fehler Ihrer Amazon – EC2-Instance mithilfe der seriellen EC2-Konsole beheben](troubleshoot-using-serial-console.md)
# Voraussetzungen für die serielle EC2-Konsole
**Topics**
+ [AWS-Regionen](#sc-prereqs-regions)
+ [Wellenlängenzonen und AWS Outposts](#sc-prereqs-wavelength-zones-outposts)
+ [Local Zones](#sc-prereqs-local-zones)
+ [Instance-Typen](#sc-prereqs-instance-types)
+ [Gewähren von Zugriff](#sc-prereqs-configure-ec2-serial-console)
+ [Unterstützung für browserbasierte Clients](#sc-prereqs-for-browser-based-connection)
+ [Instance-Status](#sc-prereqs-instance-state)
+ [Amazon EC2 Systems Manager](#sc-prereqs-ssm)
+ [Konfigurieren des von Ihnen gewählten Tools für die Fehlerbehebung](#sc-prereqs-configure-troubleshooting-tool)
## AWS-Regionen
Wird von allen unterstützt. AWS-Regionen
## Wellenlängenzonen und AWS Outposts
Nicht unterstützt
## Local Zones
Unterstützt in allen lokalen Zonen.
## Instance-Typen
Unterstützte Instance-Typen:
+ **Linux**
+ Alle virtualisierten Instances, die auf dem Nitro System aufgebaut sind.
+ Alle Bare-Metal-Instances außer:
+ Universell: `a1.metal`, `mac1.metal`, `mac2.metal`
+ Beschleunigte Datenverarbeitung: `g5g.metal`
+ RAM-optimiert: `u-6tb1.metal`, `u-9tb1.metal`, `u-12tb1.metal`, `u-18tb1.metal`, `u-24tb1.metal`
+ **Windows**
Alle virtualisierten Instances, die auf dem Nitro System aufgebaut sind. Wird nicht auf Bare-Metal-Instances unterstützt.
## Gewähren von Zugriff
Sie müssen die Konfigurationsaufgaben abschließen, um Zugriff auf die serielle EC2-Konsole zu gewähren. Weitere Informationen finden Sie unter [Konfigurieren des Zugriffs auf die serielle EC2-Konsole](configure-access-to-serial-console.md).
## Unterstützung für browserbasierte Clients
Um über den [browserbasierten Client eine Verbindung zur seriellen Konsole](connect-to-serial-console.md#sc-connect-browser-based-client) herzustellen, muss Ihr Browser dies unterstützen. WebSocket Wenn Ihr Browser dies nicht unterstützt WebSocket, stellen Sie mit [Ihrem eigenen Schlüssel und einem SSH-Client eine](connect-to-serial-console.md#sc-connect-SSH) Verbindung zur seriellen Konsole her.
## Instance-Status
Der Wert muss `running` sein.
Wenn sich die Instance in den `pending`-, `stopping`-, `stopped`-, `shutting-down`- oder `terminated`-Status befindet, können Sie keine Verbindung mit der seriellen Konsole herstellen.
Weitere Informationen zum Instance-Status finden Sie unter [Änderungen des EC2 Amazon-Instanzstatus](ec2-instance-lifecycle.md).
## Amazon EC2 Systems Manager
Wenn die Instance Amazon EC2 Systems Manager verwendet, muss SSM Agent Version 3.0.854.0 oder höher auf der Instance installiert sein. Informationen zu SSM Agent finden Sie unter [Arbeiten mit SSM Agent](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html) im *AWS Systems Manager -Benutzerhandbuch*.
## Konfigurieren des von Ihnen gewählten Tools für die Fehlerbehebung
Um Fehler in Ihrer Instanz mithilfe der seriellen Konsole zu beheben, können Sie GRUB oder SysRq auf Linux-Instances und Special Admin Console (SAC) auf Windows-Instances verwenden. Bevor Sie diese Tools verwenden können, müssen Sie zunächst Konfigurationsschritte für jede Instance ausführen, auf der Sie sie verwenden möchten.
Verwenden Sie die Anleitung für das Betriebssystem Ihrer Instance, um das von Ihnen gewählte Tool zur Fehlerbehebung zu konfigurieren.
### (Linux-Instances) GRUB konfigurieren
Um GRUB zu konfigurieren, wählen Sie eines der folgenden Verfahren basierend auf dem AMI, das zum Starten der Instance verwendet wurde.
------
#### [ Amazon Linux 2 ]
**So konfigurieren Sie GRUB für eine Amazon Linux 2-Instance**
1. [Herstellen einer Verbindung zu Ihrer Linux-Instance mit SSH](connect-to-linux-instance.md)
1. Fügen Sie die folgenden Optionen hinzu oder ändern Sie sie in `/etc/default/grub`:
+ Set `GRUB_TIMEOUT=1`.
+ Add `GRUB_TERMINAL="console serial"`.
+ Fügen Sie `GRUB_SERIAL_COMMAND="serial --speed=115200"` hinzu.
Es folgt ein Beispiel für `/etc/default/grub`. Möglicherweise müssen Sie die Konfiguration basierend auf Ihrem System-Setup ändern.
```
GRUB_CMDLINE_LINUX_DEFAULT="console=tty0 console=ttyS0,115200n8 net.ifnames=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.shell=0"
GRUB_TIMEOUT=1
GRUB_DISABLE_RECOVERY="true"
GRUB_TERMINAL="console serial"
GRUB_SERIAL_COMMAND="serial --speed=115200"
```
1. Übernehmen Sie die aktualisierte Konfiguration, indem Sie den folgenden Befehl ausführen.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
------
#### [ Ubuntu ]
**So konfigurieren Sie GRUB auf einer Ubuntu-Instance**
1. [Verbinden Sie sich mit der Instance](connect-to-linux-instance.md).
1. Fügen Sie die folgenden Optionen hinzu oder ändern Sie sie in `/etc/default/grub.d/50-cloudimg-settings.cfg`:
+ Set `GRUB_TIMEOUT=1`.
+ Add `GRUB_TIMEOUT_STYLE=menu`.
+ Fügen Sie `GRUB_TERMINAL="console serial"` hinzu.
+ Entfernen Sie `GRUB_HIDDEN_TIMEOUT`.
+ Fügen Sie `GRUB_SERIAL_COMMAND="serial --speed=115200"` hinzu.
Es folgt ein Beispiel für `/etc/default/grub.d/50-cloudimg-settings.cfg`. Möglicherweise müssen Sie die Konfiguration basierend auf Ihrem System-Setup ändern.
```
# Cloud Image specific Grub settings for Generic Cloud Images
# CLOUD_IMG: This file was created/modified by the Cloud Image build process
# Set the recordfail timeout
GRUB_RECORDFAIL_TIMEOUT=0
# Do not wait on grub prompt
GRUB_TIMEOUT=1
GRUB_TIMEOUT_STYLE=menu
# Set the default commandline
GRUB_CMDLINE_LINUX_DEFAULT="console=tty1 console=ttyS0 nvme_core.io_timeout=4294967295"
# Set the grub console type
GRUB_TERMINAL="console serial"
GRUB_SERIAL_COMMAND="serial --speed 115200"
```
1. Übernehmen Sie die aktualisierte Konfiguration, indem Sie den folgenden Befehl ausführen.
```
[ec2-user ~]$ sudo update-grub
```
------
#### [ RHEL ]
**So konfigurieren Sie GRUB auf einer RHEL-Instance**
1. [Verbinden Sie sich mit der Instance](connect-to-linux-instance.md).
1. Fügen Sie die folgenden Optionen hinzu oder ändern Sie sie in `/etc/default/grub`:
+ Entfernen Sie `GRUB_TERMINAL_OUTPUT`.
+ Add `GRUB_TERMINAL="console serial"`.
+ Fügen Sie `GRUB_SERIAL_COMMAND="serial --speed=115200"` hinzu.
Es folgt ein Beispiel für `/etc/default/grub`. Möglicherweise müssen Sie die Konfiguration basierend auf Ihrem System-Setup ändern.
```
GRUB_TIMEOUT=1
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_CMDLINE_LINUX="console=tty0 console=ttyS0,115200n8 net.ifnames=0 rd.blacklist=nouveau nvme_core.io_timeout=4294967295 crashkernel=auto"
GRUB_DISABLE_RECOVERY="true"
GRUB_ENABLE_BLSCFG=true
GRUB_TERMINAL="console serial"
GRUB_SERIAL_COMMAND="serial --speed=115200"
```
1. Übernehmen Sie die aktualisierte Konfiguration, indem Sie den folgenden Befehl ausführen.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg --update-bls-cmdline
```
Verwenden Sie unter RHEL 9.2 und älter den folgenden Befehl.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
------
#### [ CentOS ]
Für Instances, die mit einem CentOS-AMI gestartet werden, ist GRUB standardmäßig für die serielle Konsole konfiguriert.
Es folgt ein Beispiel für `/etc/default/grub`. Ihre Konfiguration kann je nach Systemeinrichtung unterschiedlich sein.
```
GRUB_TIMEOUT=1
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_TERMINAL="serial console"
GRUB_SERIAL_COMMAND="serial --speed=115200"
GRUB_CMDLINE_LINUX="console=tty0 crashkernel=auto console=ttyS0,115200"
GRUB_DISABLE_RECOVERY="true"
```
------
### (Linux-Instanzen) Konfigurieren SysRq
Zur Konfiguration SysRq aktivieren Sie die SysRq Befehle für den aktuellen Startzyklus. Um die Konfiguration dauerhaft zu machen, können Sie die SysRq Befehle auch für nachfolgende Starts aktivieren.
**Um alle SysRq Befehle für den aktuellen Startzyklus zu aktivieren**
1. [Verbinden Sie sich mit der Instance](connect-to-linux-instance.md).
1. Führen Sie den folgenden Befehl aus.
```
[ec2-user ~]$ sudo sysctl -w kernel.sysrq=1
```
Diese Einstellung wird beim nächsten Neustart gelöscht.
**Um alle SysRq Befehle für nachfolgende Starts zu aktivieren**
1. Erstellen Sie die Datei `/etc/sysctl.d/99-sysrq.conf` und öffnen Sie sie in Ihrem Lieblingseditor.
```
[ec2-user ~]$ sudo vi /etc/sysctl.d/99-sysrq.conf
```
1. Fügen Sie die folgende Zeile zu.
```
kernel.sysrq=1
```
1. Starten Sie die Instance neu, um die Änderungen zu übernehmen.
```
[ec2-user ~]$ sudo reboot
```
1. Geben Sie an der `login`-Eingabeaufforderung den Benutzernamen des passwortbasierten Benutzers ein, den Sie [vorher eingerichtet haben](configure-access-to-serial-console.md#set-user-password), und drücken Sie dann die **Eingabetaste**.
1. Geben Sie an der `Password`-Eingabeaufforderung das Passwort ein und drücken Sie dann die **Eingabetaste**.
### (Windows-Instances) SAC und Boot-Menü einrichten
**Anmerkung**
Wenn Sie SAC für eine Instance aktivieren, funktionieren die EC2-Services, die auf den Passwortabruf angewiesen sind, auf der Amazon-EC2-Konsole nicht. Windows auf Amazon-EC2-Launch-Agents (EC2Config, EC2Launch v1 und EC2Launch v2) verlassen sich bei der Ausführung verschiedener Aufgaben auf die serielle Konsole. Diese Aufgaben werden nicht erfolgreich ausgeführt, wenn Sie SAC für eine Instance aktivieren. Weitere Information zu Windows-Amazon-EC2-Startagenten erhalten Sie unter [Ihre Amazon-EC2-Instance konfigurieren](ec2-windows-instances.md). Wenn Sie SAC aktivieren, können Sie es später deaktivieren. Weitere Informationen finden Sie unter [Deaktivieren von SAC und vom Boot-Menü](troubleshoot-using-serial-console.md#disable-sac-bootmenu).
Verwenden Sie eine der folgenden Methoden, um SAC und das Bootmenü einer Instance zu aktivieren.
------
#### [ PowerShell ]
**Aktivieren von SAC und dem Boot-Menü auf einer Windows-Instance**
1. [Connect](connecting_to_windows_instance.md) zu Ihrer Instance her und führen Sie die folgenden Schritte von einer PowerShell Befehlszeile mit erhöhten Rechten aus.
1. Aktivieren Sie SAC.
```
bcdedit /ems '{current}' on
bcdedit /emssettings EMSPORT:1 EMSBAUDRATE:115200
```
1. Aktivieren Sie das Boot-Menü.
```
bcdedit /set '{bootmgr}' displaybootmenu yes
bcdedit /set '{bootmgr}' timeout 15
bcdedit /set '{bootmgr}' bootems yes
```
1. Wenden Sie die aktualisierte Konfiguration an, indem Sie die Instance neu starten.
```
shutdown -r -t 0
```
------
#### [ Command prompt ]
**Aktivieren von SAC und dem Boot-Menü auf einer Windows-Instance**
1. [Stellen Sie eine Verbindung](connecting_to_windows_instance.md) mit Ihrer Instance her und führen Sie die folgenden Schritte an der Eingabeaufforderung aus.
1. Aktivieren Sie SAC.
```
bcdedit /ems {current} on
bcdedit /emssettings EMSPORT:1 EMSBAUDRATE:115200
```
1. Aktivieren Sie das Boot-Menü.
```
bcdedit /set {bootmgr} displaybootmenu yes
bcdedit /set {bootmgr} timeout 15
bcdedit /set {bootmgr} bootems yes
```
1. Wenden Sie die aktualisierte Konfiguration an, indem Sie die Instance neu starten.
```
shutdown -r -t 0
```
------
# Konfigurieren des Zugriffs auf die serielle EC2-Konsole
Um den Zugriff auf die serielle Konsole zu konfigurieren, müssen Sie den Zugriff auf die serielle Konsole auf Kontoebene gewähren und dann IAM-Richtlinien konfigurieren, um Ihren Benutzern Zugriff zu gewähren. Sie müssen für Linux-Instances auch einen passwortbasierten Benutzer für jede Instance konfigurieren, damit Ihre Benutzer die serielle Konsole zur Fehlerbehebung verwenden können.
Die serielle EC2-Konsole verwendet eine virtuelle serielle Portverbindung, um mit einer Instance zu interagieren. Diese Verbindung ist unabhängig von der Instance-VPC, sodass Sie mit dem Instance-Betriebssystem arbeiten und Tools zur Fehlerbehebung ausführen können, auch wenn Startfehler oder Probleme mit der Netzwerkkonfiguration auftreten. Da sich diese Verbindung außerhalb des VPC-Netzwerks befindet, verwendet die serielle EC2-Konsole weder die Instance-Sicherheitsgruppe noch die Subnetz-Netzwerk-ACL, um den Datenverkehr zur Instance zu autorisieren.
**Bevor Sie beginnen**
Stellen Sie sicher, dass die [Voraussetzungen](ec2-serial-console-prerequisites.md) erfüllt sind.
**Topics**
+ [Ebenen des Zugriffs auf die serielle EC2-Konsole](#serial-console-access-levels)
+ [Verwalten des Kontozugriffs auf die serielle EC2-Konsole](#serial-console-account-access)
+ [Konfigurieren von IAM-Richtlinien für den Zugriff auf serielle EC2-Konsole](#serial-console-iam)
+ [Benutzerkennwort des Betriebssystems auf einer Linux-Instance festlegen](#set-user-password)
## Ebenen des Zugriffs auf die serielle EC2-Konsole
Standardmäßig gibt es auf Kontoebene keinen Zugriff auf die serielle Konsole. Sie müssen explizit Zugriff auf die serielle Konsole auf Kontoebene gewähren. Weitere Informationen finden Sie unter [Verwalten des Kontozugriffs auf die serielle EC2-Konsole](#serial-console-account-access).
Sie können eine Service-Kontroll-Richtlinie (SCP) verwenden, um den Zugriff auf die serielle Konsole in Ihrem Unternehmen zu ermöglichen. Sie können dann eine differenzierte Zugriffskontrolle auf Benutzerebene vornehmen, indem Sie eine IAM-Richtlinie zur Zugriffskontrolle verwenden. Durch die Verwendung einer Kombination von SCP- und IAM-Richtlinien haben Sie unterschiedliche Zugriffskontrollstufen für die serielle Konsole.
**Organisationsebene**
Sie können eine Service-Kontroll-Richtlinie (SCP) verwenden, um Mitgliedskonten in Ihrer Organisation den Zugriff auf die serielle Konsole zu ermöglichen. Weitere Informationen zu SCPs finden Sie im *AWS Organizations Benutzerhandbuch* unter [Richtlinien zur Servicesteuerung](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html).
**Instance-Ebene**
Sie können die Zugriffsrichtlinien für serielle Konsolen konfigurieren, indem Sie IAM PrincipalTag und ResourceTag Konstruktionen verwenden und Instanzen anhand ihrer ID angeben. Weitere Informationen finden Sie unter [Konfigurieren von IAM-Richtlinien für den Zugriff auf serielle EC2-Konsole](#serial-console-iam).
**Benutzerebene**
Sie können den Zugriff auf die Benutzerebene konfigurieren, indem Sie eine IAM-Richtlinie konfigurieren, um einem bestimmten Benutzer die Berechtigung zu erteilen oder zu verweigern, den öffentlichen SSH-Schlüssel an den seriellen Konsolendienst einer bestimmten Instance zu übertragen. Weitere Informationen finden Sie unter [Konfigurieren von IAM-Richtlinien für den Zugriff auf serielle EC2-Konsole](#serial-console-iam).
**Betriebssystemebene** (nur Linux-Instances)
Sie können ein Benutzerpasswort auf der Ebene des Gastbetriebssystems festlegen. Dies ermöglicht für einige Anwendungsfälle Zugriff auf die serielle Konsole. Um die Protokolle zu überwachen, benötigen Sie jedoch keinen passwortbasierten Benutzer. Weitere Informationen finden Sie unter [Benutzerkennwort des Betriebssystems auf einer Linux-Instance festlegen](#set-user-password).
## Verwalten des Kontozugriffs auf die serielle EC2-Konsole
Standardmäßig gibt es auf Kontoebene keinen Zugriff auf die serielle Konsole. Sie müssen explizit Zugriff auf die serielle Konsole auf Kontoebene gewähren.
Diese Einstellung wird auf Kontoebene konfiguriert, entweder direkt im Konto oder mithilfe einer deklarativen Richtlinie. Sie muss in allen Bereichen konfiguriert werden, in AWS-Region denen Sie Zugriff auf die serielle Konsole gewähren möchten. Mithilfe einer deklarativen Richtlinie können Sie die Einstellung auf mehrere Regionen gleichzeitig sowie auf mehrere Konten gleichzeitig anwenden. Wenn eine deklarative Richtlinie verwendet wird, können Sie die Einstellung nicht direkt in einem Konto ändern. In diesem Thema wird beschrieben, wie Sie die Einstellung direkt in einem Konto konfigurieren. Informationen zur Verwendung deklarativer Richtlinien finden Sie unter [Deklarative Richtlinien](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative.html) im *AWS Organizations -Benutzerhandbuch*.
**Contents**
+ [Gewähren von Berechtigungen für Benutzer zur Verwaltung des Kontozugriffs](#sc-account-access-permissions)
+ [Anzeigen des Kontozugriffsstatus für die serielle Konsole](#sc-view-account-access)
+ [Erteilen des Kontozugriffs auf die serielle Konsole](#sc-grant-account-access)
+ [Kontozugriff auf die serielle Konsole verweigern](#sc-deny-account-access)
### Gewähren von Berechtigungen für Benutzer zur Verwaltung des Kontozugriffs
Um Ihren Benutzern die Verwaltung des Kontozugriffs auf die serielle EC2-Konsole zu ermöglichen, müssen Sie ihnen die erforderlichen IAM-Berechtigungen gewähren.
Die folgende Richtlinie gewährt Berechtigungen zum Anzeigen des Kontostatus und zum Zulassen und Verhindern des Kontozugriffs auf die serielle EC2-Konsole.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:GetSerialConsoleAccessStatus",
"ec2:EnableSerialConsoleAccess",
"ec2:DisableSerialConsoleAccess"
],
"Resource": "*"
}
]
}
```
------
Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
### Anzeigen des Kontozugriffsstatus für die serielle Konsole
------
#### [ Console ]
**So zeigen Sie den Kontozugriff in der seriellen Konsole an**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Dashboard (Dashboard)**.
1. Wählen Sie auf der Karte mit den **Kontoattributen** unter **Einstellungen** die Option **EC2 Serial Console** aus.
1. Auf der Registerkarte **Serielle EC2-Konsole** ist der Wert von **Zugriff auf die serielle EC2-Konsole** entweder **Erlaubt** oder **Verhindert**.
------
#### [ AWS CLI ]
**So zeigen Sie den Kontozugriff in der seriellen Konsole an**
Verwenden Sie den Befehl [get-serial-console-access-status](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-serial-console-access-status.html).
```
aws ec2 get-serial-console-access-status
```
Es folgt eine Beispielausgabe. Ein Wert von `true` zeigt an, dass dem Konto Zugriff auf die serielle Konsole gewährt wird.
```
{
"SerialConsoleAccessEnabled": true,
"ManagedBy": "account"
}
```
Das `ManagedBy`-Feld gibt die Entität an, die die Einstellung konfiguriert hat. Die möglichen Werte sind `account` (direkt konfiguriert) oder `declarative-policy`. Weitere Informationen finden Sie unter [Deklarative Richtlinien](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative.html) im *AWS Organizations -Benutzerhandbuch*.
------
#### [ PowerShell ]
**So zeigen Sie den Kontozugriff in der seriellen Konsole an**
Verwenden Sie das cmdlet [Get-EC2SerialConsoleAccessStatus](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2SerialConsoleAccessStatus.html).
```
Get-EC2SerialConsoleAccessStatus -Select *
```
Es folgt eine Beispielausgabe. Ein Wert von `True` zeigt an, dass dem Konto Zugriff auf die serielle Konsole gewährt wird.
```
ManagedBy SerialConsoleAccessEnabled
--------- --------------------------
account True
```
Das `ManagedBy`-Feld gibt die Entität an, die die Einstellung konfiguriert hat. Die möglichen Werte sind `account` (direkt konfiguriert) oder `declarative-policy`. Weitere Informationen finden Sie unter [ verwaltete Richtlinien](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative.html) im *AWS Organizations -Benutzerhandbuch*.
------
### Erteilen des Kontozugriffs auf die serielle Konsole
------
#### [ Console ]
**So gewähren Sie den Kontozugriff auf die serielle Konsole**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Dashboard (Dashboard)**.
1. Wählen Sie auf der Karte **Kontoattribute** unter **Einstellungen** die Option **EC2 Serial** Console aus.
1. Wählen Sie **Manage** (Verwalten).
1. Um den Zugriff auf die serielle EC2-Konsole aller Instances im Konto zu ermöglichen, aktivieren Sie das Kontrollkästchen **Zulassen**.
1. Wählen Sie **Aktualisieren** aus.
------
#### [ AWS CLI ]
**So gewähren Sie den Kontozugriff auf die serielle Konsole**
Verwenden Sie den Befehl [enable-serial-console-access](https://docs.aws.amazon.com/cli/latest/reference/ec2/enable-serial-console-access.html).
```
aws ec2 enable-serial-console-access
```
Es folgt eine Beispielausgabe.
```
{
"SerialConsoleAccessEnabled": true
}
```
------
#### [ PowerShell ]
**So gewähren Sie den Kontozugriff auf die serielle Konsole**
Verwenden Sie das cmdlet [Enable-EC2SerialConsoleAccess](https://docs.aws.amazon.com/powershell/latest/reference/items/Enable-EC2SerialConsoleAccess.html).
```
Enable-EC2SerialConsoleAccess
```
Es folgt eine Beispielausgabe.
```
True
```
------
### Kontozugriff auf die serielle Konsole verweigern
------
#### [ Console ]
**So verweigern Sie den Kontozugriff auf die serielle Konsole**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Dashboard (Dashboard)**.
1. Wählen Sie auf der Karte **Kontoattribute** unter **Einstellungen** die Option **EC2 Serial** Console aus.
1. Wählen Sie **Manage** (Verwalten).
1. Um den Zugriff auf die serielle EC2-Konsole aller Instances im Konto zu verhindern, deaktivieren Sie das Kontrollkästchen **Zulassen**.
1. Wählen Sie **Aktualisieren** aus.
------
#### [ AWS CLI ]
**So verweigern Sie den Kontozugriff auf die serielle Konsole**
Verwenden Sie den Befehl [disable-serial-console-access](https://docs.aws.amazon.com/cli/latest/reference/ec2/disable-serial-console-access.html).
```
aws ec2 disable-serial-console-access
```
Es folgt eine Beispielausgabe.
```
{
"SerialConsoleAccessEnabled": false
}
```
------
#### [ PowerShell ]
**So verweigern Sie den Kontozugriff auf die serielle Konsole**
Verwenden Sie das cmdlet [Disable-EC2SerialConsoleAccess](https://docs.aws.amazon.com/powershell/latest/reference/items/Disable-EC2SerialConsoleAccess.html).
```
Disable-EC2SerialConsoleAccess
```
Es folgt eine Beispielausgabe.
```
False
```
------
## Konfigurieren von IAM-Richtlinien für den Zugriff auf serielle EC2-Konsole
Standardmäßig haben Ihre Benutzer keinen Zugriff auf die serielle Konsole. Ihre Organisation muss IAM-Richtlinien konfigurieren, um Ihren Benutzern den erforderlichen Zugriff zu gewähren. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
Für den seriellen Konsolenzugriff erstellen Sie ein JSON-Richtliniendokument, das die `ec2-instance-connect:SendSerialConsoleSSHPublicKey`-Aktion enthält. Diese Aktion gewährt einem Benutzer die Berechtigung, den öffentlichen Schlüssel an den seriellen Konsolenservice zu übertragen, der eine serielle Konsolensitzung startet. Wir empfehlen die Einschränkung des Zugriffs auf bestimmte EC2-Instances. Andernfalls können alle Benutzer mit dieser Berechtigung eine Verbindung zur seriellen Konsole aller EC2-Instances herstellen.
**Topics**
+ [Zulassen des Zugriffs auf die serielle Konsole](#iam-explicitly-allow-access)
+ [Explizites Verweigern des Zugriffs auf die serielle Konsole](#serial-console-IAM-policy)
+ [Verwenden von Ressourcen-Tags (Markierungen), um den Zugriff auf die serielle Konsole zu kontrollieren](#iam-resource-tags)
### Zulassen des Zugriffs auf die serielle Konsole
Standardmäßig hat niemand Zugriff auf die serielle Konsole. Um den Zugriff auf die serielle Konsole zu gewähren, müssen Sie eine Richtlinie konfigurieren, um den Zugriff explizit zuzulassen. Wir empfehlen, eine Richtlinie zu konfigurieren, die den Zugriff auf bestimmte Instances einschränkt.
Die folgende Richtlinie ermöglicht den Zugriff auf die serielle Konsole einer bestimmten Instance, die durch ihre Instance-ID identifiziert wird.
Beachten Sie, dass die `DescribeInstances`-, `DescribeInstanceTypes`-, und `GetSerialConsoleAccessStatus`-Aktionen keine Berechtigungen auf Ressourcenebene unterstützen. Daher müssen alle Ressourcen, die durch ein `*` (Sternchen) gekennzeichnet sind, für diese Aktionen spezifiziert werden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDescribeInstances",
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeInstanceTypes",
"ec2:GetSerialConsoleAccessStatus"
],
"Resource": "*"
},
{
"Sid": "AllowinstanceBasedSerialConsoleAccess",
"Effect": "Allow",
"Action": [
"ec2-instance-connect:SendSerialConsoleSSHPublicKey"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/i-0598c7d356eba48d7"
}
]
}
```
------
### Explizites Verweigern des Zugriffs auf die serielle Konsole
Die folgende IAM-Richtlinie ermöglicht den Zugriff auf die serielle Konsole aller Instances, die durch das `*` (Sternchen) gekennzeichnet ist, und verweigert ausdrücklich den Zugriff auf die serielle Konsole einer bestimmten Instance, die durch ihre ID identifiziert wird.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowSerialConsoleAccess",
"Effect": "Allow",
"Action": [
"ec2-instance-connect:SendSerialConsoleSSHPublicKey",
"ec2:DescribeInstances",
"ec2:DescribeInstanceTypes",
"ec2:GetSerialConsoleAccessStatus"
],
"Resource": "*"
},
{
"Sid": "DenySerialConsoleAccess",
"Effect": "Deny",
"Action": [
"ec2-instance-connect:SendSerialConsoleSSHPublicKey"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/i-0598c7d356eba48d7"
}
]
}
```
------
### Verwenden von Ressourcen-Tags (Markierungen), um den Zugriff auf die serielle Konsole zu kontrollieren
Sie können Ressourcen-Tags (Markierungen) verwenden, um den Zugriff auf die serielle Konsole einer Instance zu steuern.
Die attributbasierte Zugriffskontrolle ist eine Autorisierungsstrategie, bei der Berechtigungen auf der Grundlage von Tags definiert werden, die Benutzern und Ressourcen zugewiesen werden können. AWS Beispielsweise ermöglicht die folgende Richtlinie einem Benutzer, eine serielle Konsolenverbindung für eine Instance nur dann zu initiieren, wenn das Ressourcen-Tag dieser Instance und das Tag des Prinzipals denselben `SerialConsole`-Wert für den Tag-Schlüssel haben.
Weitere Informationen zur Verwendung von Tags zur Steuerung des Zugriffs auf Ihre AWS Ressourcen finden Sie unter [Steuern des Zugriffs auf AWS Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html#access_tags_control-resources) im *IAM-Benutzerhandbuch*.
Beachten Sie, dass die `DescribeInstances`-, `DescribeInstanceTypes`-, und `GetSerialConsoleAccessStatus`-Aktionen keine Berechtigungen auf Ressourcenebene unterstützen. Daher müssen alle Ressourcen, die durch ein `*` (Sternchen) gekennzeichnet sind, für diese Aktionen spezifiziert werden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDescribeInstances",
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeInstanceTypes",
"ec2:GetSerialConsoleAccessStatus"
],
"Resource": "*"
},
{
"Sid": "AllowTagBasedSerialConsoleAccess",
"Effect": "Allow",
"Action": [
"ec2-instance-connect:SendSerialConsoleSSHPublicKey"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/SerialConsole": "${aws:PrincipalTag/SerialConsole}"
}
}
}
]
}
```
------
## Benutzerkennwort des Betriebssystems auf einer Linux-Instance festlegen
Sie können sich ohne Passwort mit der seriellen Konsole verbinden. Um jedoch die serielle Konsole für die Fehlerbehebung einer Instance *verwenden* zu können, muss die Instance über einen passwortbasierten Betriebssystem-Benutzer verfügen.
Sie können das Kennwort für jeden Betriebssystembenutzer festlegen, einschließlich des Stammbenutzers. Beachten Sie, dass der Stammbenutzer alle Dateien ändern kann, während jeder Betriebssystembenutzer möglicherweise eingeschränkte Berechtigungen hat.
Sie müssen für jede Instance, für die Sie die serielle Konsole verwenden, ein Benutzerkennwort festlegen. Dies ist eine einmalige Anforderung für jede Instance.
**Anmerkung**
Standardmäßig AWS sind AMIs provided by nicht mit einem kennwortbasierten Benutzer konfiguriert. Wenn Sie Ihre Instance mit einem AMI gestartet haben, für das das Root-Benutzerkennwort bereits konfiguriert ist, können Sie diese Anweisungen überspringen.
**Benutzerkennwort des Betriebssystems auf einer Linux-Instance festlegen**
1. [Verbinden Sie sich mit der Instance](connect-to-linux-instance.md). Sie können eine beliebige Methode für die Verbindung mit Ihrer Instance verwenden, mit Ausnahme der seriellen EC2-Konsolen-Verbindungsmethode.
1. Verwenden Sie den **passwd**-Befehl, um das Kennwort für einen Benutzer festzulegen. Im folgenden Beispiel ist der Benutzer `root`.
```
[ec2-user ~]$ sudo passwd root
```
Es folgt eine Beispielausgabe.
```
Changing password for user root.
New password:
```
1. Geben Sie an der `New password`-Eingabeaufforderung das neue Passwort ein.
1. Geben Sie an der Eingabeaufforderung das Passwort erneut ein.
# Herstellen einer Verbindung zur seriellen EC2-Konsole
Sie können über die Amazon-EC2-Konsole oder über SSH eine Verbindung mit der seriellen Konsole Ihrer EC2-Instance herstellen. Nachdem Sie eine Verbindung zur seriellen Konsole hergestellt haben, können Sie sie zur Fehlerbehebung bei Booten, Netzwerkkonfiguration und anderen Problemen verwenden. Weitere Informationen zur Fehlerbehebung finden Sie unter [Fehler Ihrer Amazon – EC2-Instance mithilfe der seriellen EC2-Konsole beheben](troubleshoot-using-serial-console.md).
**Überlegungen**
+ Pro Instance wird nur 1 aktive serielle Konsolenverbindung unterstützt.
+ Die Verbindung zur seriellen Konsole dauert normalerweise 1 Stunde, außer Sie [trennen die Verbindung](disconnect-serial-console-session.md). Allerdings beendet Amazon EC2 während der Systemwartung die serielle Konsolensitzung.
Die Dauer der Verbindung wird nicht durch die Dauer Ihrer IAM-Anmeldeinformationen bestimmt. Wenn Ihre IAM-Anmeldeinformationen ablaufen, bleibt die Verbindung bestehen, bis die maximale Dauer der seriellen Konsolenverbindung erreicht ist. Wenn Sie das Konsolenerlebnis der seriellen EC2-Konsole verwenden und Ihre IAM-Anmeldeinformationen ablaufen, beenden Sie die Verbindung, indem Sie die Browserseite schließen.
+ Es dauert 30 Sekunden, um eine Sitzung abzubrechen, nachdem Sie die Verbindung zur seriellen Konsole getrennt haben, um eine neue Sitzung zuzulassen.
+ Unterstützte serielle Konsolenanschlüsse: `ttyS0` (Linux-Instances) und `COM1` (Windows-Instances)
+ Wenn Sie eine Verbindung zur seriellen Konsole herstellen, können Sie einen leichten Rückgang des Durchsatzes Ihrer Instance feststellen.
**Topics**
+ [Herstellen von Verbindungen über den browserbasierten Client](#sc-connect-browser-based-client)
+ [Herstellen von Verbindungen über Ihren eigenen Schlüssel und einen SSH-Client](#sc-connect-SSH)
+ [Endpunkte und Fingerabdrücke der seriellen EC2-Konsole](#sc-endpoints-and-fingerprints)
## Herstellen von Verbindungen über den browserbasierten Client
Sie können eine Verbindung mit der seriellen Konsole Ihrer EC2-Instance herstellen, indem Sie den browserbasierten Client verwenden. Dazu wählen Sie die Instance in der Amazon EC2-Konsole aus und wählen, eine Verbindung zur seriellen Konsole herzustellen. Der browserbasierte Client verarbeitet die Berechtigungen und stellt eine erfolgreiche Verbindung bereit.
Die serielle EC2-Konsole funktioniert von den meisten Browsern und unterstützt Tastatur- und Mauseingaben.
Stellen Sie vor dem Verbinden sicher, dass Sie die [Voraussetzungen](ec2-serial-console-prerequisites.md) erfüllt haben.
**So stellen Sie mithilfe des browserbasierten Clients (Amazon EC2-Konsole) eine Verbindung mit dem seriellen Port Ihrer Instance her**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie die Instance und **Actions** (Aktionen), **Monitor and troubleshoot** (Überprüfen und Fehler beheben), **EC2 Serial Console** (Serielle EC2-Konsole), **Connect** (Verbinden) aus.
Alternativ können Sie die Instance markieren und wählen Sie **Connect** (Verbinden), **EC2 Serial Console** (Serielle EC2-Konsole), **Connect** (Verbinden).
Ein Terminalfenster im Browser wird geöffnet.
1. Drücken Sie die **Eingabetaste**. Wenn eine Anmeldeaufforderung zurückkehrt, sind Sie mit der seriellen Konsole verbunden.
Wenn der Bildschirm schwarz bleibt, können Sie die folgenden Informationen verwenden, um Probleme bei der Verbindung mit der seriellen Konsole zu beheben:
+ **Stellen Sie sicher, dass Sie den Zugriff auf die serielle Konsole konfiguriert haben.** Weitere Informationen finden Sie unter [Konfigurieren des Zugriffs auf die serielle EC2-Konsole](configure-access-to-serial-console.md).
+ (Nur Linux-Instanzen) Wird **verwendet SysRq , um eine Verbindung zur seriellen Konsole herzustellen**. SysRq erfordert nicht, dass Sie die Verbindung über den browserbasierten Client herstellen. Weitere Informationen finden Sie unter [(Linux-Instanzen) Verwenden Sie diese Option, um Fehler in Ihrer Instanz zu beheben SysRqSysRq (Linux)](troubleshoot-using-serial-console.md#SysRq).
+ (Nur Linux-Instances) **Starten Sie getty neu.** Wenn Sie SSH-Zugriff auf Ihre Instance haben, stellen Sie mithilfe von SSH eine Verbindung zu Ihrer Instance her und starten Sie Getty mit dem folgenden Befehl neu.
```
[ec2-user ~]$ sudo systemctl restart serial-getty@ttyS0
```
+ **Starten Sie Ihre Instance neu.** Sie können Ihre Instance mithilfe von SysRq (Linux-Instances), der EC2-Konsole oder dem neu starten. AWS CLI Weitere Informationen finden Sie unter [(Linux-Instanzen) Verwenden Sie diese Option, um Fehler in Ihrer Instanz zu beheben SysRqSysRq (Linux)](troubleshoot-using-serial-console.md#SysRq) (Linux-Instances) oder [Starten Sie Ihre EC2 Amazon-Instance neu](ec2-instance-reboot.md).
1. (Nur Linux-Instances) Geben Sie an der `login`-Eingabeaufforderung den Benutzernamen des passwortbasierten Benutzers ein, den Sie [zuvor eingerichtet haben](configure-access-to-serial-console.md#set-user-password), und drücken Sie dann die **Eingabetaste**.
1. (Nur Linux-Instances) Geben Sie an der `Password`-Eingabeaufforderung das Passwort ein und drücken Sie dann die **Eingabetaste**.
## Herstellen von Verbindungen über Ihren eigenen Schlüssel und einen SSH-Client
Sie können mittels Ihres eigenen SSH-Schlüssels über einen SSH-Client Ihrer Wahl Verbindungen mit Ihrer Instance herstellen, während Sie die serielle Konsolen-API verwenden. Auf diese Weise können Sie die serielle Konsolenfunktion für die Push-Übergabe öffentlicher Schlüssel an Instances nutzen.
Nachdem Sie den SSH-Schlüssel auf die Instance übertragen haben, unterliegt die SSH-Verbindung nicht den IAM-Richtlinien, die Sie konfiguriert haben, um Benutzern Zugriff auf die serielle EC2-Konsole zu gewähren.
**Bevor Sie beginnen**
Stellen Sie sicher, dass die [Voraussetzungen](ec2-serial-console-prerequisites.md) erfüllt sind.
**So stellen Sie eine Verbindung mit der seriellen Konsole einer Instance über SSH her**
1. **Schieben Sie Ihren öffentlichen SSH-Schlüssel auf die Instance, um eine Sitzung der seriellen Konsole zu starten**
Verwenden Sie den Befehl [send-serial-console-ssh-public-key](https://docs.aws.amazon.com/cli/latest/reference/ec2-instance-connect/send-serial-console-ssh-public-key.html), um Ihren öffentlichen SSH-Schlüssel auf die Instance zu übertragen. Dies startet eine serielle Konsolensitzung.
Wenn für diese Instance bereits eine serielle Konsolensitzung gestartet wurde, schlägt der Befehl fehl, da Sie jeweils nur eine Sitzung geöffnet haben können. Es dauert 30 Sekunden, um eine Sitzung abzubrechen, nachdem Sie die Verbindung zur seriellen Konsole getrennt haben, um eine neue Sitzung zuzulassen.
```
aws ec2-instance-connect send-serial-console-ssh-public-key \
--instance-id i-001234a4bf70dec41EXAMPLE \
--serial-port 0 \
--ssh-public-key file://my_key.pub \
--region us-east-1
```
1.
**Stellen Sie mit Ihrem privaten Schlüssel eine Verbindung zur seriellen Konsole her**
Verwenden Sie den **ssh**-Befehl, um eine Verbindung mit der seriellen Konsole herzustellen, bevor der öffentliche Schlüssel aus dem seriellen Konsolendienst entfernt wird. Sie haben 60 Sekunden bevor er entfernt wird.
Verwenden Sie den privaten Schlüssel, der dem öffentlichen Schlüssel entspricht.
Das Benutzernamenformat, das die Instance-ID und den Port 0 umfasst, ist `instance-id.port0`. Im folgenden Beispiel lautet der Benutzername `i-001234a4bf70dec41EXAMPLE.port0`.
Der Endpunkt des seriellen Konsolendienstes ist für jede Region unterschiedlich. In der [Endpunkte und Fingerabdrücke der seriellen EC2-Konsole](#sc-endpoints-and-fingerprints) Tabelle finden Sie die Endpunkte der einzelnen Regionen. Im folgenden Beispiel befindet sich der serielle Konsolendienst in der Region us-east-1.
```
ssh -i my_key i-001234a4bf70dec41EXAMPLE.port0@serial-console.ec2-instance-connect.us-east-1.aws
```
Im folgenden Beispiel wird `timeout 3600` verwendet, um Ihre SSH-Sitzung nach 1 Stunde zu beenden. Während der Sitzung gestartete Prozesse können auch nach Beendigung der Sitzung auf Ihrer Instance weiter ausgeführt werden.
```
timeout 3600 ssh -i my_key i-001234a4bf70dec41EXAMPLE.port0@serial-console.ec2-instance-connect.us-east-1.aws
```
1.
**(Optional) Überprüfen Sie den Fingerabdruck**
Wenn Sie zum ersten Mal eine Verbindung mit der seriellen Konsole herstellen, werden Sie aufgefordert, den Fingerabdruck zu überprüfen. Sie können den Fingerabdruck der seriellen Konsole mit dem Fingerabdruck vergleichen, der zur Überprüfung angezeigt wird. Wenn diese Fingerabdrücke nicht übereinstimmen, versucht möglicherweise jemand einen "" -Angriff. man-in-the-middle Wenn sie übereinstimmen, können Sie sich sicher mit der seriellen Konsole verbinden.
Der folgende Fingerabdruck gilt für den seriellen Konsolendienst in der Region us-east-1. Informationen zu den Fingerabdrücken für die einzelnen Regionen finden Sie unter [Endpunkte und Fingerabdrücke der seriellen EC2-Konsole](#sc-endpoints-and-fingerprints).
```
SHA256:dXwn5ma/xadVMeBZGEru5l2gx+yI5LDiJaLUcz0FMmw
```
Der Fingerabdruck wird nur angezeigt, wenn Sie zum ersten Mal eine Verbindung mit der seriellen Konsole herstellen.
1. Drücken Sie die **Eingabetaste**. Wenn eine Eingabeaufforderung zurückkehrt, sind Sie mit der seriellen Konsole verbunden.
Wenn der Bildschirm schwarz bleibt, können Sie die folgenden Informationen verwenden, um Probleme bei der Verbindung mit der seriellen Konsole zu beheben:
+ **Stellen Sie sicher, dass Sie den Zugriff auf die serielle Konsole konfiguriert haben.** Weitere Informationen finden Sie unter [Konfigurieren des Zugriffs auf die serielle EC2-Konsole](configure-access-to-serial-console.md).
+ (Nur Linux-Instanzen) Wird **verwendet SysRq , um eine Verbindung zur seriellen Konsole** herzustellen. SysRq erfordert nicht, dass Sie eine Verbindung über SSH herstellen. Weitere Informationen finden Sie unter [(Linux-Instanzen) Verwenden Sie diese Option, um Fehler in Ihrer Instanz zu beheben SysRqSysRq (Linux)](troubleshoot-using-serial-console.md#SysRq).
+ (Nur Linux-Instances) **Starten Sie getty neu.** Wenn Sie SSH-Zugriff auf Ihre Instance haben, stellen Sie mithilfe von SSH eine Verbindung zu Ihrer Instance her und starten Sie Getty mit dem folgenden Befehl neu.
```
[ec2-user ~]$ sudo systemctl restart serial-getty@ttyS0
```
+ **Starten Sie Ihre Instance neu.** Sie können Ihre Instance neu starten, indem Sie SysRq (nur Linux-Instances), die EC2-Konsole oder die verwenden. AWS CLI Weitere Informationen finden Sie unter [(Linux-Instanzen) Verwenden Sie diese Option, um Fehler in Ihrer Instanz zu beheben SysRqSysRq (Linux)](troubleshoot-using-serial-console.md#SysRq) (nur Linux-Instances) oder [Starten Sie Ihre EC2 Amazon-Instance neu](ec2-instance-reboot.md).
1. (Nur Linux-Instances) Geben Sie an der `login`-Eingabeaufforderung den Benutzernamen des passwortbasierten Benutzers ein, den Sie [zuvor eingerichtet haben](configure-access-to-serial-console.md#set-user-password), und drücken Sie dann die **Eingabetaste**.
1. (Nur Linux-Instances) Geben Sie an der `Password`-Eingabeaufforderung das Passwort ein und drücken Sie dann die **Eingabetaste**.
## Endpunkte und Fingerabdrücke der seriellen EC2-Konsole
Im Folgenden sind die Service-Endpunkte und Fingerabdrücke für die serielle EC2-Konsole aufgeführt. Um programmgesteuert eine Verbindung zur seriellen Konsole einer Instance herzustellen, verwenden Sie einen EC2 Serial Console-Endpunkt. Die Endpunkte und Fingerabdrücke der seriellen EC2-Konsole sind für jede AWS -Region einzigartig.
| Name der Region | Region | Endpoint | Fingerabdruck |
| --- | --- | --- | --- |
| USA Ost (Ohio) | us-east-2 | serial-console.ec2-instance-connect.us-east-2.aws | SHA256: EhwPkTzRt TY7 TRSzz26 RM7m CZN0xw xbb0/HVV9J /d/0 |
| USA Ost (Nord-Virginia) | us-east-1 | serial-console.ec2-instance-connect.us-east-1.aws | SHA256: VMe BZGEru5l2gx LDi xbb0/HVV9J /d/0 ----SEP -----: dxwn5mA/xAD\$1yI5 Ja LUcz0 FMmw |
| USA West (Nordkalifornien) | us-west-1 | serial-console.ec2-instance-connect.us-west-1.aws | SHA256: H3Y OHldlc MET8u7 QLSX3jm RTRAPFHVtqbyo LZBMUCqi |
| USA West (Oregon) | us-west-2 | serial-console.ec2-instance-connect.us-west-2.aws | SHA256: O2Jx EMCIe23 TqKa BI6y GHainq ZcMwqNkDhh AVHa1 VUc |
| Afrika (Kapstadt) | af-south-1 | ec2-serial-console.af-south-1.api.aws | SHA256: O5JL2 21ed00biiwi RMWWZ2f VePe JUqzj KIg XsczoHlz |
| Asien-Pazifik (Hongkong) | ap-east-1 | ec2-serial-console.ap-east-1.api.aws | SHA256: lpiXxCho ZHpln o5JL2 XVi 21ED00BIIWI ----SEP -----: T0Q1 AKJBP7TKM2x C9b Ynifk JFsj |
| Asien-Pazifik (Taipeh) | ap-east-2 | ec2-serielle Konsole.ap-east-2.api.aws | SHA256DE8aQqsHwBrec2-serial-console.ap-east-2.api.aws ----sep----:Z1RSF5 /D40TR2 FwDQ GnyMqnSc CUa1z1e |
| Asien-Pazifik (Hyderabad) | ap-south-2 | ec2-serial-console.ap-south-2.api.aws | SHA256: v4/SHN\$1 15 WJg PBSw OPITValoew AuYj DVW845 JEh DKRs |
| Asien-Pazifik (Jakarta) | ap-southeast-3 | ec2-serial-console.ap-southeast-3.api.aws | SHA256: ZwgrCh V4/Sun\$1 XITq 15 YFqy3o8m ----sep----:5 \$1lfns32 l/4O0ZIFBX4BZGS Ik |
| Asien-Pazifik (Malaysia) | ap-southeast-5 | ec2-serial-console.ap-southeast-5.api.aws | SHA256QXTHQMRcqRdIjmAGoAMBSExeoRobYyRwec2-serial-console.ap-southeast-5.api.aws ----sep----:c T67 A yTjnEi |
| Asien-Pazifik (Neuseeland) | ap-southeast-6 | ec2-serial-console.ap-southeast-6.api.aws | SHA256HJKjrwec2-serial-console.ap-southeast-6.api.aws ----sep----:WNLTDH0GVFM5U \$1 CS\$1LLKv4 ElFuKoJgalc SKqj |
| Asien-Pazifik (Melbourne) | ap-southeast-4 | ec2-serial-console.ap-southeast-4.api.aws | SHA256:WNLTDH0GVFM5U \$1 CS\$1LLKV4 ----SEP----:AVAQ27 5g hFgLvjn Z0OV7H90P0 oET6 M TSSh GG46wf ZJv |
| Asien-Pazifik (Mumbai) | ap-south-1 | serial-console.ec2-instance-connect.ap-south-1.aws | SHA256:Avaq27 BLXc 5g HHEbli ARx TPi SM35 Z0ov7H90P0 oeT6 M ----sep----:o Ymklq egh8ISO51REZ BSU40 |
| Asia Pacific (Osaka) | ap-northeast-3 | ec2-serial-console.ap-northeast-3.api.aws | SHA256:o BKBn BuFnHr Ymklq EV3 egh8iso51REZ BSU40 ----sep----:AM0/Ji 9axSG G8tu/vvhfxe/3ucyJSQ |
| Asien-Pazifik (Seoul) | ap-northeast-2 | serielle Konsole.ec2-instance-connect.ap-northeast-2.aws | SHA256:AM0/Ji NTztg9 PK49 WYMq 9axSG G8TU/VVHFXE/3UCYJSQ ZM2d ----SEP----:FOQWXNX\$1DZ\$1\$1GU bx\$1FRC SRQRi |
| Asien-Pazifik (Singapur) | ap-southeast-1 | serial-console.ec2-instance-connect.ap-southeast-1.aws | SHA256: Ein Lu1Gy/L8 Zuac6L45CoY PLFNn7 CQDHx3qmw TUX7 LQg |
| Asien-Pazifik (Sydney) | ap-southeast-2 | serial-console.ec2-instance-connect.ap-southeast-2.aws | SHA256: yFvMw UK9l EUQj QTRo XXzu VSe9 N\$1Cw9/W984Cf5Tgzo4 |
| Asien-Pazifik (Thailand) | ap-southeast-7 | ec2-serial-console.ap-southeast-7.api.aws | SHA256: R1q2lqsg7 2wmj DY KCAZi RYr vTwixWmvc VT31 XRg SdEf |
| Asien-Pazifik (Tokio) | ap-northeast-1 | serial-console.ec2-instance-connect.ap-northeast-1.aws | SHA256: RQfs DCZTOf Qawew Em/ TRDV1t9 \$1 HMr FQe CRl IOT5um4k |
| Kanada (Zentral) | ca-central-1 | serial-console.ec2-instance-connect.ca-central-1.aws | SHA256: OZwmp Qawew YW738 FIOTHd UTy Em/ \$1 ----SEP----:P2O2J mWKPO6 EV2Gcz YMMO7s4 |
| Kanada West (Calgary) | ca-west-1 | ec2-serial-console.ca-west-1.api.aws | SHA256:P2O2J mWKPO6 EV2GCZ ----SEP----:S3RC8LI2XHBHR3IEDJ 6Q JNx GAFLPGOLjx7 IxxXrGckk |
| China (Beijing) | cn-north-1 | ec2-serial-console---cn-north-1---api.amazonwebservices.com.rproxy.goskope.com.cn | SHA256:S3RC8LI2XHBHR3IEDJ 6Q ----sep----:2 g H7UU3\$1WA D28V/LGGT\$1Y HVFy4 FUx ggMeqjvSlgngpg |
| China (Ningxia) | cn-northwest-1 | appmesh---cn-northwest-1---api.amazonwebservices.com.rproxy.goskope.com.cn | SHA256: 2 g NZki QOd H7UU3\$1WA D28 YEBUh V/LGGT\$1Y -------- SEP -----: TDGR Vf O4Sz M UA09 VWI5r YOZGTogpwmi |
| Europa (Frankfurt) | eu-central-1 | serial-console.ec2-instance-connect.eu-central-1.aws | SHA256:Tdgr yIcOd OlkXvOl Vf JJ3 O4Sz M ----SEP----:ACMFS/8AMZ1TOE\$1BBNR FY0K0DE2C |
| Europa (Irland) | eu-west-1 | serial-console.ec2-instance-connect.eu-west-1.aws | SHA256:ACMFS/ GAWO4 qTrHj ZAw CW6 8AMZ1TOE\$1BBNR FY0K0DE2C ----SEP----:H2AA HATHHTM6EZS3BJ7UDGUXI2 E |
| Europa (London) | eu-west-2 | serial-console.ec2-instance-connect.eu-west-2.aws | SHA256:H2AA CE/AEG4Amm53I6lkD1ZPvS/BCV TPW2 RnJg HAthHTM6EZS3BJ7UDGUXI2 E ----sep----:a69rd5 3t 8 |
| Europa (Milan) | eu-south-1 | ec2-serial-console.eu-south-1.api.aws | SHA256:a69rd5 OVJnpg 3t BVrxn0 8 ----sep----:LC0K Fy a7N99ecLb S7X7 XSX95cuu QK30 |
| Europa (Paris) | eu-west-3 | serial-console.ec2-instance-connect.eu-west-3.aws | SHA256:Lc0k FVng Fy RPAr A7N99eCLB S7X7 ----sep----:Q8LDNAF9PYMENE8BN Y3 /kxsw JUzfrlxe EWs |
| Europa (Spain) | eu-south-2 | ec2-serial-console.eu-south-2.api.aws | SHA256:Q8LDNAF9PYMENE8BN Y3 /kxsw CW2 DFRlu669 QNxq FxEcs ----SEP----:GO R6f /4F4N7T45 ZUz ZcwoEc |
| Europa (Stockholm) | eu-north-1 | serial-console.ec2-instance-connect.eu-north-1.aws | SHA256:Go GFFUVUDvoc R6f GSS3 /4F4N7T45 ----sep----:tk Di CU8GDL6W2ui32 X84 EPNp KFKLw |
| Europa (Zürich) | eu-central-2 | ec2-serial-console.eu-central-2.api.aws | SHA256:tk BMf6 WdCw Di NUlz CU8GDL6W2UI32 X84 ----sep----:8PPX2M 0 KFWM4/ IfRz 4Oa XFut QXWp6mk |
| Israel (Tel Aviv) | il-central-1 | ec2-serial-console.il-central-1.api.aws | SHA256: \$1 Nm JR6q8v6k NNPi8 QSFQ4dj5dim M1 Yu ZPTgwgs SNvt |
| Mexiko (Zentral) | mx-central-1 | ec2-serial-console.mx-central-1.api.aws | SHA256: BCu VL13i QNk \$1 18EF4P2 FeTB32 CcVnt ZHUr BBAOxl GS0 |
| Naher Osten (Bahrain) | me-south-1 | ec2-serial-console.me-south-1.api.aws | SHA256: LLKHu2 QnLdUq VL13i VArso \$1 PJOMRJKCBz CDq 18EF4P2 FETB32 ----SEP----:NPJ 2k K5xV C3k8 |
| Naher Osten (VAE) | me-central-1 | ec2-serial-console.me-central-1.api.aws | SHA256:NPJ dFwPeyyk 2k MPBYh K5xV XNe FSDKBv C3K8 ----SEP----:ZPB5DUKIBZ\$1L0 B4 I/Xz LE |
| Südamerika (São Paulo) | sa-east-1 | serial-console.ec2-instance-connect.sa-east-1.aws | SHA256:ZPB5DUKIBZ\$1L0 B4 I/Xz LE ----sep----:RD2\$1/32OGNJEW1Y QZC\$1BOTBIH62OQ I VIem ENa APDq1d |
| AWS GovCloud (USA-Ost) | us-gov-east-1 | serielle Konsole.ec2-Instanzenverbindung. us-gov-east-1.amazonaws.com | SHA256GWsoyLClrtvu38YEEh-1.amazonaws.com ----SEP----:TIWE19 \$1 F28 DHIkqn DcZnmtebv |
| AWS GovCloud (US-West) | us-gov-west-1 | serielle Konsole.ec2-Instanzenverbindung. us-gov-west-1.amazonaws.com | SHA256-1.amazonaws.com ----sep----:kf b\$1UTBD3BRF8 8n iW5DQ OFRWLa OZf OlPf GO2 YZLq XZi |
# Trennen der Verbindung mit der seriellen EC2-Konsole
Wenn Sie nicht mehr mit der seriellen EC2-Konsole Ihrer Instance verbunden sein müssen, können Sie die Verbindung trennen. Wenn Sie die Verbindung zur seriellen Konsole trennen, wird jede Shell-Sitzung, die auf der Instance ausgeführt wird, weiterhin ausgeführt. Wenn Sie die Shell-Sitzung beenden möchten, müssen Sie sie beenden, bevor Sie die Verbindung zur seriellen Konsole trennen.
**Überlegungen**
+ Die Verbindung zur seriellen Konsole dauert normalerweise 1 Stunde, sofern Sie sie nicht beenden. Allerdings beendet Amazon EC2 während der Systemwartung die serielle Konsolensitzung.
+ Es dauert 30 Sekunden, um eine Sitzung abzubrechen, nachdem Sie die Verbindung zur seriellen Konsole getrennt haben, um eine neue Sitzung zuzulassen.
Die Art und Weise, wie die Verbindung zur seriellen Konsole getrennt wird, hängt vom Client ab.
**Browserbasierter Client**
Um die Verbindung zur seriellen Konsole zu trennen, schließen Sie das Terminalfenster der seriellen Konsole im Browser.
**Standard-OpenSSH-Client**
Um die Verbindung zur seriellen Konsole zu trennen, verwenden Sie den folgenden Befehl, um die SSH-Verbindung zu schließen. Dieser Befehl muss unmittelbar nach einer neuen Zeile ausgeführt werden.
```
~.
```
Der Befehl, den Sie zum Schließen einer SSH-Verbindung verwenden, kann je nach verwendetem SSH-Client unterschiedlich sein.
# Fehler Ihrer Amazon – EC2-Instance mithilfe der seriellen EC2-Konsole beheben
Mithilfe der seriellen EC2-Konsole können Sie Boot-, Netzwerkkonfigurations- und andere Probleme beheben, indem Sie eine Verbindung zum seriellen Port Ihrer Instance herstellen.
Verwenden Sie die Anleitung für das Betriebssystem Ihrer Instance und für das Tool, das Sie auf Ihrer Instance konfiguriert haben.
**Topics**
+ [GRUB (Linux)](#grub)
+ [SysRq (Linux)](#SysRq)
+ [SAC (Windows)](#troubleshooting-sac)
**Voraussetzungen**
Bevor Sie beginnen, stellen Sie sicher, dass Sie die [Voraussetzungen](ec2-serial-console-prerequisites.md) erfüllt haben, einschließlich der Konfiguration Ihres ausgewählten Tools zur Fehlerbehebung.
## (Linux-Instances) GRUB verwenden, um Fehler in Ihrer Instance zu beheben
GNU GRUB (kurz für GNU GRand Unified Bootloader, allgemein als GRUB bezeichnet) ist der Standard-Bootloader für die meisten Linux-Betriebssysteme. Im GRUB-Menü können Sie auswählen, in welchen Kernel Sie booten möchten oder Menüeinträge ändern, um den Bootvorgang des Kernels zu ändern. Dies kann bei der Problembehandlung einer fehlerhaften Instance nützlich sein.
Das GRUB-Menü wird während des Startvorgangs angezeigt. Das Menü ist nicht über normales SSH zugänglich, Sie können jedoch über die serielle EC2-Konsole darauf zugreifen.
Sie können in den Einzelbenutzermodus oder in den Notfallmodus starten. Der Einzelbenutzermodus bootet den Kernel auf ein niedrigeres Runlevel. Zum Beispiel könnte es das Dateisystem einhängen, aber das Netzwerk nicht aktivieren, was Ihnen die Möglichkeit gibt, die Wartung durchzuführen, die zum Reparieren der Instance erforderlich ist. Der Notfallmodus ähnelt dem Einzelbenutzermodus, mit der Ausnahme, dass der Kernel auf dem niedrigsten möglichen Runlevel läuft.
**So booten Sie in den Einzelbenutzermodus**
1. [Stellen Sie eine Verbindung](connect-to-serial-console.md) mit der seriellen Konsole der Instance her.
1. Starten Sie die Instance mit dem folgenden Befehl neu.
```
[ec2-user ~]$ sudo reboot
```
1. Wenn während des Neustarts das GRUB-Menü angezeigt wird, drücken Sie eine beliebige Taste, um den Bootvorgang zu beenden.
1. Verwenden Sie im GRUB-Menü die Pfeiltasten, um den zu bootenden Kernel auszuwählen, und drücken Sie `e` auf Ihrer Tastatur.
1. Verwenden Sie die Pfeiltasten, um den Cursor in der Zeile zu finden, die den Kernel enthält. Die Zeile beginnt mit `linux` oder `linux16`, abhängig von dem AMI, das zum Starten der Instance verwendet wurde. Für Ubuntu beginnen zwei Zeilen mit `linux`, die beide im nächsten Schritt geändert werden müssen.
1. Am Ende der Zeile fügen Sie das Wort `single` hinzu.
Im Folgenden finden Sie ein Beispiel für Amazon Linux 2.
```
linux /boot/vmlinuz-4.14.193-149.317.amzn2.aarch64 root=UUID=d33f9c9a-\
dadd-4499-938d-ebbf42c3e499 ro console=tty0 console=ttyS0,115200n8 net.ifname\
s=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.she\
ll=0 single
```
1. Drücken Sie **Strg\$1X**, um in den Einzelbenutzermodus zu starten.
1. Geben Sie an der `login`-Eingabeaufforderung den Benutzernamen des passwortbasierten Benutzers ein, den Sie [vorher eingerichtet haben](configure-access-to-serial-console.md#set-user-password), und drücken Sie dann die **Eingabetaste**.
1. Geben Sie an der `Password`-Eingabeaufforderung das Passwort ein und drücken Sie dann die **Eingabetaste**.
**In den Notfallmodus starten**
Gehen Sie genauso vor wie im Einzelbenutzermodus, fügen Sie jedoch in Schritt 6 das Wort `emergency` anstelle von `single` hinzu.
## (Linux-Instanzen) Verwenden Sie diese Option, um Fehler in Ihrer Instanz zu beheben SysRq
Der Schlüssel System Request (SysRq), der manchmal auch als SysRq „Magic“ bezeichnet wird, kann verwendet werden, um dem Kernel direkt außerhalb einer Shell einen Befehl zu senden, und der Kernel wird antworten, unabhängig davon, was der Kernel tut. Wenn die Instanz beispielsweise nicht mehr reagiert, können Sie den SysRq Schlüssel verwenden, um dem Kernel mitzuteilen, dass er abstürzen oder neu starten soll. Weitere Informationen finden Sie unter [Magic SysRq Key](https://en.wikipedia.org/wiki/Magic_SysRq_key) in Wikipedia.
Sie können SysRq Befehle im browserbasierten Client für die EC2 Serial Console oder in einem SSH-Client verwenden. Der Befehl zum Senden einer Unterbrechungsanfrage ist für jeden Client unterschiedlich.
Wählen Sie zur Verwendung SysRq je nach verwendetem Client eines der folgenden Verfahren aus.
------
#### [ Browser-based client ]
**Zur Verwendung SysRq in der seriellen Konsole (browserbasierter Client)**
1. [Stellen Sie eine Verbindung](connect-to-serial-console.md) mit der seriellen Konsole der Instance her.
1. Um eine Unterbrechungsanfrage zu senden, drücken Sie `CTRL+0` (Null). Wenn Ihre Tastatur dies unterstützt, können Sie auch eine Unterbrechungsanfrage mit der Pause- oder Break-Taste senden.
```
[ec2-user ~]$ CTRL+0
```
1. Um einen SysRq Befehl auszuführen, drücken Sie die Taste auf Ihrer Tastatur, die dem gewünschten Befehl entspricht. Um beispielsweise eine Liste mit SysRq Befehlen anzuzeigen, drücken Sie`h`.
```
[ec2-user ~]$ h
```
Der `h`-Befehl gibt etwas Ähnliches wie das Folgende aus.
```
[ 1169.389495] sysrq: HELP : loglevel(0-9) reboot(b) crash(c) terminate-all-tasks(e) memory-full-oom-kill(f) kill-all-tasks(i) thaw-filesystems
(j) sak(k) show-backtrace-all-active-cpus(l) show-memory-usage(m) nice-all-RT-tasks(n) poweroff(o) show-registers(p) show-all-timers(q) unraw(r
) sync(s) show-task-states(t) unmount(u) show-blocked-tasks(w) dump-ftrace-buffer(z)
```
------
#### [ SSH client ]
**Zur Verwendung SysRq in einem SSH-Client**
1. [Stellen Sie eine Verbindung](connect-to-serial-console.md) mit der seriellen Konsole der Instance her.
1. Um eine Unterbrechungsanfrage zu senden, drücken Sie `~B` (Tilde, gefolgt von Großbuchstaben `B`).
```
[ec2-user ~]$ ~B
```
1. Um einen SysRq Befehl auszuführen, drücken Sie die Taste auf Ihrer Tastatur, die dem gewünschten Befehl entspricht. Um beispielsweise eine Liste mit SysRq Befehlen anzuzeigen, drücken Sie`h`.
```
[ec2-user ~]$ h
```
Der `h`-Befehl gibt etwas Ähnliches wie das Folgende aus.
```
[ 1169.389495] sysrq: HELP : loglevel(0-9) reboot(b) crash(c) terminate-all-tasks(e) memory-full-oom-kill(f) kill-all-tasks(i) thaw-filesystems
(j) sak(k) show-backtrace-all-active-cpus(l) show-memory-usage(m) nice-all-RT-tasks(n) poweroff(o) show-registers(p) show-all-timers(q) unraw(r
) sync(s) show-task-states(t) unmount(u) show-blocked-tasks(w) dump-ftrace-buffer(z)
```
**Anmerkung**
Der Befehl, den Sie zum Senden einer Unterbrechungsanfrage verwenden, kann je nach verwendetem SSH-Client unterschiedlich sein.
------
## (Windows-Instances) SAC zur Fehlerbehebung Ihrer Instance verwenden
Die Special-Admin-Console(SAC)-Funktion von Windows bietet eine Möglichkeit zur Fehlerbehebung einer Windows-Instance. Wenn Sie eine Verbindung zur seriellen Konsole der Instance herstellen und SAC verwenden, können Sie den Startvorgang unterbrechen und Windows im abgesicherten Modus starten.
**Anmerkung**
Wenn Sie SAC für eine Instance aktivieren, funktionieren die EC2-Services, die auf den Passwortabruf angewiesen sind, auf der Amazon-EC2-Konsole nicht. Windows auf Amazon-EC2-Launch-Agents (EC2Config, EC2Launch v1 und EC2Launch v2) verlassen sich bei der Ausführung verschiedener Aufgaben auf die serielle Konsole. Diese Aufgaben werden nicht erfolgreich ausgeführt, wenn Sie SAC für eine Instance aktivieren. Weitere Information zu Windows-Amazon-EC2-Startagenten erhalten Sie unter [Ihre Amazon-EC2-Instance konfigurieren](ec2-windows-instances.md). Wenn Sie SAC aktivieren, können Sie es später deaktivieren. Weitere Informationen finden Sie unter [Deaktivieren von SAC und vom Boot-Menü](#disable-sac-bootmenu).
**Topics**
+ [Verwenden von SAC](#use-sac)
+ [Verwenden des Boot-Menüs](#use-boot-menu)
+ [Deaktivieren von SAC und vom Boot-Menü](#disable-sac-bootmenu)
### Verwenden von SAC
**So verwenden Sie SAC**
1. [Stellen Sie eine Verbindung mit der seriellen Konsole her.](connect-to-serial-console.md)
Wenn SAC auf der Instance aktiviert ist, zeigt die serielle Konsole die `SAC>`-Anfrage an.
![\[In der seriellen Konsole wird ein SAC-Prompt angezeigt.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-3.png)
1. Geben Sie zum Anzeigen der SAC-Befehle „?“ ein und drücken Sie dann die **Eingabetaste**.
Erwartete Ausgabe
![\[Geben Sie ein Fragezeichen ein, um die SAC-Befehle anzuzeigen.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-4.png)
1. Um einen Eingabeaufforderungskanal (z. B. `cmd0001` oder `cmd0002`) zu erstellen, geben Sie cmd ein und drücken Sie dann die **Eingabetaste**.
1. Um den Eingabeaufforderungskanal anzuzeigen, drücken Sie **ESC** und drücken Sie dann auf **TAB**.
Erwartete Ausgabe
![\[Der Eingabeaufforderungskanal.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-5.png)
1. Um Kanäle zu wechseln, drücken Sie **ESC\$1Tab\$1Kanalnummer** gleichzeitig. Um zum Beispiel zum `cmd0002`-Kanal (falls er erstellt wurde) zu wechseln, drücken Sie **ESC\$1TAB\$12**.
1. Geben Sie die für den Eingabeaufforderungskanal erforderlichen Anmeldeinformationen ein.
![\[Die Eingabeaufforderung, die Anmeldeinformationen erfordert.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-6.png)
Die Eingabeaufforderung ist dieselbe voll funktionsfähige Command Shell, die Sie auf einem Desktop erhalten, mit der Ausnahme, dass sie das Lesen von bereits ausgegebenen Zeichen nicht zulässt.
![\[Eine Befehls-Shell mit vollem Funktionsumfang.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-7.png)
**PowerShell kann auch von der Befehlszeile aus verwendet werden.**
Beachten Sie, dass Sie möglicherweise die Einstellung Fortschritt auf den stillen Modus festlegen müssen.
![\[PowerShell innerhalb der Befehlszeile.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-8.png)
### Verwenden des Boot-Menüs
Wenn für die Instance das Boot-Menü aktiviert ist und nach der Verbindung über SSH neu gestartet wird, sollten Sie das Startmenü wie folgt sehen.
![\[Das Startmenü in der Eingabeaufforderung.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-1.png)
**Befehle im Boot-Menü**
EINGEBEN
Startet den ausgewählten Eintrag des Betriebssystems.
Tabulatortaste
Wechselt zum Tools-Menü.
ESC
Bricht die Instance ab und startet sie neu.
ESC, gefolgt von 8
Entspricht dem Drücken von **F8**. Zeigt erweiterte Optionen für das ausgewählte Element an.
ESC-Taste \$1 linke Pfeiltaste
Geht zurück zum anfänglichen Boot-Menü.
Die ESC-Taste allein bringt Sie nicht zurück zum Hauptmenü, da Windows darauf wartet, zu sehen, ob eine Escapesequenz läuft.
![\[Erweiterte Startoptionen.\]](http://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/images/win-boot-2.png)
### Deaktivieren von SAC und vom Boot-Menü
Wenn Sie SAC und das Boot-Menü aktivieren, können Sie diese Funktionen später deaktivieren.
Verwenden Sie eine der folgenden Methoden, um SAC und das Boot-Menü einer Instance zu deaktivieren.
------
#### [ PowerShell ]
**So deaktivieren Sie SAC und das Boot-Menü auf einer Windows-Instance**
1. [Connect](connecting_to_windows_instance.md) zu Ihrer Instance her und führen Sie die folgenden Schritte von einer PowerShell Befehlszeile mit erhöhten Rechten aus.
1. Deaktivieren Sie zuerst das Boot-Menü, indem Sie den Wert in `no` ändern.
```
bcdedit /set '{bootmgr}' displaybootmenu no
```
1. Deaktivieren Sie dann SAC, indem Sie den Wert auf `off` setzen.
```
bcdedit /ems '{current}' off
```
1. Wenden Sie die aktualisierte Konfiguration an, indem Sie die Instance neu starten.
```
shutdown -r -t 0
```
------
#### [ Command prompt ]
**So deaktivieren Sie SAC und das Boot-Menü auf einer Windows-Instance**
1. [Stellen Sie eine Verbindung](connecting_to_windows_instance.md) mit Ihrer Instance her und führen Sie die folgenden Schritte an der Eingabeaufforderung aus.
1. Deaktivieren Sie zuerst das Boot-Menü, indem Sie den Wert in `no` ändern.
```
bcdedit /set {bootmgr} displaybootmenu no
```
1. Deaktivieren Sie dann SAC, indem Sie den Wert auf `off` setzen.
```
bcdedit /ems {current} off
```
1. Wenden Sie die aktualisierte Konfiguration an, indem Sie die Instance neu starten.
```
shutdown -r -t 0
```
------
# Senden einer Diagnose-Unterbrechung, um eine unerreichbare Amazon-EC2-Instance zu debuggen
**Warnung**
Diagnose-Interrupts sind für fortgeschrittene Benutzer vorgesehen. Eine falsche Verwendung kann sich negativ auf Ihre Instance auswirken. Das Senden eines Diagnose-Interrupts an eine Instance kann zum Absturz und Neustart einer Instance führen, was unter Umständen den Verlust von Daten zur Folge hat.
Sie können eine Diagnose-Unterbrechung an eine nicht erreichbare oder nicht reagierende Instance senden, um manuell eine *Kernel-Panik* für eine Linux-Instance oder einen *Anhalte-Fehler* (allgemein als *Bluescreen-Fehler* bezeichnet) für eine Windows-Instance auszulösen.
**Linux-Instances**
Linux-Betriebssysteme stürzen bei einer Kernel-Panik gewöhnlich ab und werden neu gestartet. Das spezifische Verhalten des Betriebssystems ist von seiner Konfiguration abhängig. Mit einer Kernel-Panik kann das Betriebssystem der Instance auch zum Ausführen von Aufgaben, z. B. Generieren einer Dump-Datei, veranlasst werden. Sie können dann mithilfe der Informationen in der Absturzabbilddatei eine Ursachenanalyse durchführen und die Instance debuggen. Die Absturzabbilddaten werden lokal von dem Betriebssystem auf der Instance selbst erstellt.
**Windows-Instances**
Im Allgemeinen stürzen Windows-Betriebssysteme ab und werden neu gestartet, wenn ein Abbruchfehler auftritt, das spezifische Verhalten hängt aber von seiner Konfiguration ab. Ein Abbruchfehler kann auch bewirken, dass das Betriebssystem Debugging-Informationen, wie z. B. ein Kernel-Speicherabbild, in einer Datei ausgibt. Sie können anhand dieser Informationen eine Ursachenanalyse durchführen, um die Instance zu debuggen. Die Speicherabbilddaten werden lokal von dem Betriebssystem auf der Instance selbst erstellt.
Bevor Sie ein Diagnose-Interrupt an Ihre Instance senden, empfehlen wir Ihnen, die Dokumentation für Ihr Betriebssystem zu konsultieren und anschließend die erforderlichen Konfigurationsänderungen vorzunehmen.
**Topics**
+ [Unterstützte Instance-Typen](#diagnostic-interrupt-instances)
+ [Voraussetzungen](#diagnostic-interrupt-prereqs)
+ [Senden eines Diagnose-Interrupts](#diagnostic-interrupt-use)
## Unterstützte Instance-Typen
Der Diagnose-Interrupt wird auf allen Nitro-basierten Instanztypen unterstützt, mit Ausnahme derjenigen, die mit AWS Graviton-Prozessoren betrieben werden. [Weitere Informationen finden Sie unter [Instances, die auf dem AWS Nitro System und Graviton basieren](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html).AWS](https://aws.amazon.com/ec2/graviton/)
## Voraussetzungen
Bevor Sie einen Diagnose-Interrupt verwenden, müssen Sie das Betriebssystem der Instance entsprechend konfigurieren. Dadurch wird sichergestellt, dass die Aktionen ausgeführt werden, die Sie benötigen, wenn eine Kernel-Panik (Linux-Instances) oder ein Stop-Fehler (Windows-Instances) auftritt.
### Linux-Instances
**Amazon Linux 2 oder Amazon Linux 2023 zum Generieren eines Absturzabbildes bei Auftreten einer Kernel-Panik konfigurieren**
1. Verbinden Sie sich mit der Instance.
1. Installieren Sie **kexec** und **kdump**.
```
[ec2-user ~]$ sudo yum install kexec-tools -y
```
1. Konfigurieren Sie den Kernel zum Reservieren einer angemessenen Menge an Arbeitsspeicher für den sekundären Kernel. Die Menge an Arbeitsspeicher ist von dem insgesamt verfügbaren Arbeitsspeicher Ihrer Instance abhängig. Öffnen Sie die Datei `/etc/default/grub` in Ihrem bevorzugten Texteditor, suchen Sie die Zeile, die mit `GRUB_CMDLINE_LINUX_DEFAULT` beginnt, und fügen Sie dann den Parameter `crashkernel` im folgenden Format hinzu: `crashkernel=memory_to_reserve`. Um beispielsweise `256MB` zu reservieren, ändern Sie die Datei `grub` wie folgt ab:
```
GRUB_CMDLINE_LINUX_DEFAULT="crashkernel=256M console=tty0 console=ttyS0,115200n8 net.ifnames=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.shell=0"
GRUB_TIMEOUT=0
GRUB_DISABLE_RECOVERY="true"
```
1. Speichern Sie Ihre Änderungen und schließen Sie die Datei `grub`.
1. Erstellen Sie die GRUB2 Konfigurationsdatei neu.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. Bei Instances auf Intel- und AMD-Prozessoren sendet der Befehl `send-diagnostic-interrupt` einen *unbekannten nicht maskierbaren Interrupt* (NMI) an die Instance. Sie müssen den Kernel so konfigurieren, dass er bei Eingang des unbekannten NMI abstürzt. Öffnen Sie die Datei `/etc/sysctl.conf` mit Ihrem bevorzugten Texteditor und fügen Sie Folgendes hinzu.
```
kernel.unknown_nmi_panic=1
```
1. Starten Sie Ihre Instance neu und richten Sie wieder eine Verbindung zu ihr ein.
1. Vergewissern Sie sich, dass der Kernel mit dem richtigen `crashkernel`-Parameter gestartet wurde.
```
$ grep crashkernel /proc/cmdline
```
Die folgende Beispielausgabe weist auf eine erfolgreiche Konfiguration hin.
```
BOOT_IMAGE=/boot/vmlinuz-4.14.128-112.105.amzn2.x86_64 root=UUID=a1e1011e-e38f-408e-878b-fed395b47ad6 ro crashkernel=256M console=tty0 console=ttyS0,115200n8 net.ifnames=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.shell=0
```
1. Überprüfen Sie, ob der **kdump**-Service ausgeführt wird.
```
[ec2-user ~]$ systemctl status kdump.service
```
Die folgende Beispielausgabe zeigt das Ergebnis, wenn der Service **kdump** derzeit ausgeführt wird.
```
kdump.service - Crash recovery kernel arming
Loaded: loaded (/usr/lib/systemd/system/kdump.service; enabled; vendor preset: enabled)
Active: active (exited) since Fri 2019-05-24 23:29:13 UTC; 22s ago
Process: 2503 ExecStart=/usr/bin/kdumpctl start (code=exited, status=0/SUCCESS)
Main PID: 2503 (code=exited, status=0/SUCCESS)
```
**Anmerkung**
Die Absturzabbilddatei wird standardmäßig in `/var/crash/` gespeichert. Um den Speicherort zu ändern, bearbeiten Sie die Datei `/etc/kdump.conf` mit Ihrem bevorzugten Texteditor.
**So konfigurieren Sie SUSE Linux Enterprise, Ubuntu oder Red Hat Enterprise Linux**
Bei Instances auf Intel- und AMD-Prozessoren sendet der Befehl `send-diagnostic-interrupt` einen *unbekannten nicht maskierbaren Interrupt* (NMI) an die Instance. Sie müssen den Kernel so konfigurieren, dass er bei Eingang des unbekannten NMI abstürzt, indem Sie die Konfigurationsdatei für Ihr Betriebssystem anpassen. Informationen darüber, wie Sie den Kernel so konfigurieren, dass er abstürzt, finden Sie in der Dokumentation für Ihr Betriebssystem:
+ [SUSE Linux Enterprise](https://www.suse.com/support/kb/doc/?id=3374462)
+ [Ubuntu ](https://ubuntu.com/server/docs/kernel-crash-dump)
+ [ Red Hat Enterprise Linux (RHEL)](https://access.redhat.com/solutions/6038)
### Windows-Instances
**So konfigurieren Sie Windows zum Generieren eines Speicherabbilds bei Auftreten von Abbruchfehlern**
1. Verbinden Sie sich mit der Instance.
1. Öffnen Sie die **Systemsteuerung** und wählen Sie **System**, **Erweiterte Systemeinstellungen**.
1. Wählen Sie im Dialogfeld **Systemeigenschaften** die Registerkarte **Erweitert** aus.
1. Wählen Sie im Bereich **Startup und Wiederherstellen** die Option **Einstellungen...**.
1. Konfigurieren Sie die Einstellungen im Bereich **Systemfehler** ganz nach Bedarf und wählen Sie dann **OK**.
Weitere Informationen zum Konfigurieren von Windows-Abbruchfehlern finden Sie unter [ Overview of memory dump file options for Windows](https://support.microsoft.com/en-us/help/254649/overview-of-memory-dump-file-options-for-windows).
## Senden eines Diagnose-Interrupts
Nachdem Sie die erforderlichen Konfigurationsänderungen vorgenommen haben, können Sie mithilfe der AWS CLI oder der Amazon EC2 EC2-API einen Diagnose-Interrupt an Ihre Instance senden.
------
#### [ AWS CLI ]
**So senden Sie einen Diagnose-Interrupt an Ihre Instance**
Verwenden Sie den Befehl [send-diagnostic-interrupt](https://docs.aws.amazon.com/cli/latest/reference/ec2/send-diagnostic-interrupt.html).
```
aws ec2 send-diagnostic-interrupt --instance-id i-1234567890abcdef0
```
------
#### [ PowerShell ]
**So senden Sie einen Diagnose-Interrupt an Ihre Instance**
Verwenden Sie das cmdlet [Send-EC2DiagnosticInterrupt](https://docs.aws.amazon.com/powershell/latest/reference/items/Send-EC2DiagnosticInterrupt.html).
```
Send-EC2DiagnosticInterrupt -InstanceId i-1234567890abcdef0
```
------