Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# 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 Instance- IDs, Resource-Tags und anderen IAM-Hebeln auf granularer Ebene 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 in allen Ländern AWS-Regionen außer im asiatisch-pazifischen Raum (Taipeh) unterstützt.
## 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 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 (Hyderabad) | ap-south-2 | ec2-serial-console.ap-south-2.api.aws | SHA256: WJg PBSw V4/Sun\$1 15 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 (Melbourne) | ap-southeast-4 | ec2-serial-console.ap-southeast-4.api.aws | SHA256:c hFgLvjn T67 TSSh A GG46wf ZJv ----SEP----:AVAQ27 5g Z0OV7H90P0 oET6 M |
| 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 (USA-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 Eingabeaufforderung.\]](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
```
------