

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.

# Arbeiten mit Active Directory mit RDS für SQL Server
<a name="User.SQLServer.ActiveDirectoryWindowsAuth"></a>

Sie können eine RDS-für-SQL-Server-DB-Instance einer Microsoft Active Directory (AD)-Domain hinzufügen. Ihre AD-Domain kann auf AWS Managed AD innerhalb AWS oder in einem selbstverwalteten AD an einem Standort Ihrer Wahl, einschließlich Ihrer Unternehmensrechenzentren AWS EC2, auf oder bei anderen Cloud-Anbietern gehostet werden.

Sie können Domänenbenutzer mithilfe der NTLM-Authentifizierung und der Kerberos-Authentifizierung mit selbstverwaltetem Active Directory und authentifizieren. AWS Managed Microsoft AD

In den folgenden Abschnitten finden Sie Informationen zur Arbeit mit selbstverwaltetem Active Directory und AWS Managed Active Directory für Microsoft SQL Server auf Amazon RDS.

**Topics**
+ [

# Arbeiten mit selbstverwaltetem Active Directory mit einer DB-Instance von Amazon RDS für SQL Server
](USER_SQLServer_SelfManagedActiveDirectory.md)
+ [

# Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server
](USER_SQLServerWinAuth.md)

# Arbeiten mit selbstverwaltetem Active Directory mit einer DB-Instance von Amazon RDS für SQL Server
<a name="USER_SQLServer_SelfManagedActiveDirectory"></a>

Amazon RDS für SQL Server lässt sich nahtlos in Ihre selbstverwaltete Active Directory (AD)-Domain integrieren, unabhängig davon, wo Ihr AD gehostet wird – in Ihrem Rechenzentrum, in Amazon EC2 oder bei anderen Cloud-Anbietern. Diese Integration ermöglicht die direkte Benutzerauthentifizierung über NTLM- oder Kerberos-Protokolle, sodass keine komplexen Zwischen-Domains oder Gesamtstruktur-Vertrauensstellungen erforderlich sind. Wenn Sie eine Verbindung zu Ihrer DB-Instance von RDS für SQL Server herstellen, werden Authentifizierungsanfragen sicher an Ihre angegebene AD-Domain weitergeleitet, wobei Ihre bestehende Identitätsverwaltungsstruktur beibehalten und gleichzeitig die verwalteten Datenbankfunktionen von Amazon RDS genutzt werden.

**Topics**
+ [

## Verfügbarkeit von Regionen und Versionen
](#USER_SQLServer_SelfManagedActiveDirectory.RegionVersionAvailability)
+ [

# Voraussetzungen
](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md)
+ [

## Überlegungen
](#USER_SQLServer_SelfManagedActiveDirectory.Limitations)
+ [

# Einrichten eines selbstverwalteten Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.SettingUp.md)
+ [

# Hinzufügen Ihrer DB-Instance zu Ihrem selbstverwalteten Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.Joining.md)
+ [

# Verwalten einer DB-Instance in einer selbstverwalteten Active-Directory-Domain
](USER_SQLServer_SelfManagedActiveDirectory.Managing.md)
+ [

## Grundlegendes zur Mitgliedschaft in einer selbstverwalteten Active-Directory-Domain
](#USER_SQLServer_SelfManagedActiveDirectory.Understanding)
+ [

# Fehlerbehebung für selbstverwaltetes Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.TroubleshootingSelfManagedActiveDirectory.md)
+ [

## Wiederherstellen einer SQL-Server-DB-Instance und Hinzufügen zu einer selbstverwalteten Active-Directory-Domain
](#USER_SQLServer_SelfManagedActiveDirectory.Restore)

## Verfügbarkeit von Regionen und Versionen
<a name="USER_SQLServer_SelfManagedActiveDirectory.RegionVersionAvailability"></a>

Amazon RDS unterstützt selbstverwaltetes AD für SQL Server mit NTLM und Kerberos in allen kommerziellen und. AWS-Regionen AWS GovCloud (US) Regions

# Voraussetzungen
<a name="USER_SQLServer_SelfManagedActiveDirectory.Requirements"></a>

Stellen Sie sicher, dass die folgenden Anforderungen erfüllt sind, bevor Sie eine RDS-für-SQL-Server-DB-Instance Ihrer selbstverwalteten AD-Domain hinzufügen.

**Topics**
+ [

## Konfigurieren Ihres On-Premises-AD
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.OnPremConfig)
+ [

## Konfigurieren Ihrer Netzwerkkonnektivität
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig)
+ [

## Konfigurieren Ihres AD-Domain-Servicekontos
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig)
+ [

## Konfigurieren der sicheren Kommunikation über LDAPS
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.LDAPS)

## Konfigurieren Ihres On-Premises-AD
<a name="USER_SQLServer_SelfManagedActiveDirectory.Requirements.OnPremConfig"></a>

Stellen Sie sicher, dass Sie über ein On-Premises-AD oder ein anderes selbstverwaltetes Microsoft-AD verfügen, der Sie die Amazon-RDS-für-SQL- Server-Instance hinzufügen können. Ihr On-Premises-AD sollte folgende Konfiguration aufweisen:
+ Wenn Sie AD-Standorte definiert haben, stellen Sie sicher, dass die Subnetze in der VPC, die Ihrer DB-Instance von RDS für SQL Server zugeordnet sind, an Ihrem AD-Standort definiert sind. Vergewissern Sie sich, dass keine Konflikte zwischen den Subnetzen in Ihrer VPC und den Subnetzen an Ihren anderen AD-Standorten bestehen.
+ Ihr AD-Domain-Controller weist die Domain-Funktionsebene Windows Server 2008 R2 oder höher auf.
+ Ihr AD-Domain-Name darf nicht im SLD-Format (Single Label Domain) vorliegen. RDS für SQL Server unterstützt keine SLD-Domains.
+ Der vollständig qualifizierte Domain-Name (Fully Qualified Domain Name, FQDN) für Ihr AD darf 47 Zeichen nicht überschreiten.

## Konfigurieren Ihrer Netzwerkkonnektivität
<a name="USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig"></a>

Stellen Sie sicher, dass die folgenden Netzwerkkonfigurationsanforderungen erfüllt sind:
+ Die Konnektivität zwischen der Amazon VPC, in der Sie die DB-Instance von RDS für SQL Server erstellen möchten, und Ihrem selbstverwalteten AD wurde konfiguriert. Sie können Konnektivität über AWS Direct Connect, AWS VPN, VPC-Peering oder AWS Transit Gateway einrichten.
+ Für VPC-Sicherheitsgruppen wurde die Standardsicherheitsgruppe für Ihre standardmäßige Amazon VPC bereits in der Konsole zu Ihrer RDS-für-SQL-Server-DB-Instance hinzugefügt. Stellen Sie sicher, dass die Sicherheitsgruppe und das VPC-Netzwerk ACLs für die Subnetze, in denen Sie Ihre RDS for SQL Server-DB-Instance erstellen, Datenverkehr auf den Ports und in den Anweisungen zulassen, die in der folgenden Abbildung dargestellt sind.  
![\[Selbstverwaltetes AD – Netzwerkkonfiguration – Portregeln.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQLServer_SelfManagedActiveDirectory_Requirements_NetworkConfig.png)

  In der folgenden Tabelle ist die Rolle der einzelnen Ports aufgeführt.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/USER_SQLServer_SelfManagedActiveDirectory.Requirements.html)
+ Im Allgemeinen befinden sich die Domain-DNS-Server in den AD-Domain-Controllern. Zur Verwendung dieser Funktion müssen Sie den VPC-DHCP-Optionssatz nicht konfigurieren. Weitere Informationen finden Sie unter [DHCP-Optionssätze](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html) im *Amazon-VPC-Benutzerhandbuch*.

**Wichtig**  
Wenn Sie ein VPC-Netzwerk verwenden ACLs, müssen Sie auch ausgehenden Datenverkehr auf dynamischen Ports (49152-65535) von Ihrer RDS for SQL Server-DB-Instance zulassen. Stellen Sie sicher, dass sich diese Datenverkehrsregeln auch auf den Firewalls widerspiegeln, die für die einzelnen AD-Domain-Controller, DNS-Server und RDS-für-SQL-Server-DB-Instances gelten.  
Während für VPC-Sicherheitsgruppen Ports nur in der Richtung geöffnet werden müssen, in der der Netzwerkverkehr initiiert wird, ACLs erfordern die meisten Windows-Firewalls und VPC-Netzwerke, dass Ports in beide Richtungen geöffnet sind.

## Konfigurieren Ihres AD-Domain-Servicekontos
<a name="USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig"></a>

Stellen Sie sicher, dass die folgenden Anforderungen für ein AD-Domain-Servicekonto erfüllt sind:
+ Stellen Sie sicher, dass Sie in Ihrer selbstverwalteten AD-Domain über ein Domain-Servicekonto mit delegierten Berechtigungen zum Hinzufügen von Computern zu der Domain verfügen. Ein Domain-Servicekonto ist ein Benutzerkonto in Ihrem selbstverwalteten AD, an das die Berechtigung zur Ausführung bestimmter Aufgaben delegiert wurde.
+ An das Domain-Servicekonto müssen in der Organisationseinheit, der Sie Ihre RDS-für-SQL-Server-DB-Instance hinzufügen, die folgenden Berechtigungen delegiert werden:
  + Überprüfte Fähigkeit zum Schreiben in den DNS-Hostnamen
  + Überprüfte Fähigkeit zum Schreiben in den Prinzipalnamen des Service
  + Erstellen und Löschen von Computerobjekten

  Dies sind die erforderlichen Mindestberechtigungen, um Computerobjekte zu Ihrem selbstverwalteten AD hinzuzufügen. Weitere Informationen finden Sie unter [Fehler beim Versuch, Computer einer Domain hinzuzufügen](https://learn.microsoft.com/en-US/troubleshoot/windows-server/identity/access-denied-when-joining-computers) in der Dokumentation zu Microsoft Windows Server.
+ Um die Kerberos-Authentifizierung zu verwenden, müssen Sie Ihrem AD-Domänendienstkonto Service Principal Names (SPNs) und DNS-Berechtigungen zuweisen:
  + **SPN schreiben**: Delegieren Sie die Berechtigung **SPN Schreiben** an das AD-Domain-Servicekonto in der Organisationseinheit, in der Sie der DB-Instance von RDS für SQL Server beitreten müssen. Diese Berechtigungen unterscheiden sich von validierten SPN-Schreibvorgängen.
  + **DNS-Berechtigungen**: Geben Sie die folgenden Berechtigungen für das AD-Domain-Servicekonto im DNS-Manager auf Serverebene für Ihren Domain-Controller ein:
    + Inhalt auflisten
    + Alle Eigenschaften lesen
    + Berechtigungen lesen

**Wichtig**  
Verschieben Sie keine Computerobjekte, die RDS für SQL Server in der Organisationseinheit erstellt, nachdem Ihre DB-Instance erstellt wurde. Wenn Sie die zugehörigen Objekte verschieben, wird Ihre RDS-für-SQL-Server-DB-Instance falsch konfiguriert. Wenn Sie die von Amazon RDS erstellten Computerobjekte verschieben müssen, verwenden Sie den Vorgang [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API, um die Domänenparameter mit dem gewünschten Speicherort der Computerobjekte zu ändern.

## Konfigurieren der sicheren Kommunikation über LDAPS
<a name="USER_SQLServer_SelfManagedActiveDirectory.Requirements.LDAPS"></a>

Die Kommunikation über LDAPS wird für RDS zur Abfrage und zum Zugriff auf Computerobjekte sowie SPNs im Domänencontroller empfohlen. Um sicheres LDAP zu nutzen, verwenden Sie ein gültiges SSL-Zertifikat auf Ihrem Domain-Controller, das die Anforderungen für sicheres LDAPS erfüllt. Wenn auf dem Domain-Controller kein gültiges SSL-Zertifikat vorhanden ist, verwendet die DB-Instance von RDS für SQL Server standardmäßig LDAP. Weitere Informationen zur Gültigkeit von Zertifikaten finden Sie unter [Requirements for an LDAPS certificate](https://learn.microsoft.com/en-us/troubleshoot/windows-server/active-directory/enable-ldap-over-ssl-3rd-certification-authority#requirements-for-an-ldaps-certificate).

## Überlegungen
<a name="USER_SQLServer_SelfManagedActiveDirectory.Limitations"></a>

Beachten Sie Folgendes, wenn Sie eine DB-Instance von RDS für SQL Server zu einem selbstverwalteten AD hinzufügen:
+ Ihre DB-Instances werden mit dem AWS NTP-Dienst und nicht mit dem Zeitserver der AD-Domain synchronisiert. Für Datenbankverbindungen zwischen verknüpften SQL-Server-Instances innerhalb Ihrer AD-Domain können Sie nur die SQL-Authentifizierung und nicht die Windows-Authentifizierung verwenden.
+ Gruppenrichtlinienobjekteinstellungen aus Ihrer selbstverwalteten AD-Domäne werden nicht an Ihre RDS für SQL Server-Instanzen weitergegeben.

# Einrichten eines selbstverwalteten Active Directory
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp"></a>

Gehen Sie wie folgt vor, um ein selbstverwaltetes AD einzurichten.

**Topics**
+ [

## Schritt 1: Erstellen einer Organisationseinheit in Ihrem AD
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateOU)
+ [

## Schritt 2: Erstellen eines AD-Domain-Servicekontos in Ihrem AD
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateADuser)
+ [

## Schritt 3: Delegieren der Kontrolle an das AD-Domain-Servicekonto
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.DelegateControl)
+ [

## Schritt 4: Erstellen Sie einen Schlüssel AWS KMS
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateKMSkey)
+ [

## Schritt 5: Erstellen Sie ein AWS Geheimnis
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateSecret)

## Schritt 1: Erstellen einer Organisationseinheit in Ihrem AD
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateOU"></a>

**Wichtig**  
 Wir empfehlen, für jedes AWS Konto, das eine RDS for SQL Server-DB-Instance besitzt, die Ihrer selbstverwalteten AD-Domäne beigetreten ist, eine dedizierte Organisationseinheit und Dienstanmeldedaten zu erstellen, die auf diese Organisationseinheit beschränkt sind. Durch die Zuordnung einer Organisationseinheit und von Service-Anmeldeinformationen können Sie widersprüchliche Berechtigungen vermeiden und dem Prinzip der geringsten Berechtigung folgen. 

**So erstellen Sie eine Organisationseinheit in Ihrem AD**

1. Stellen Sie als Domain-Administrator eine Verbindung zu Ihrer AD-Domain her.

1. Öffnen Sie **Active Directory-Benutzer und -Computer** und wählen Sie die Domain aus, in der Sie Ihre Organisationseinheit erstellen möchten.

1. Klicken Sie mit der rechten Maustaste auf die Domain und wählen Sie **Neu** und dann **Organisationseinheit** aus.

1. Geben Sie einen Namen für die Organisationseinheit ein.

1. Lassen Sie das Kontrollkästchen für **Container vor versehentlichem Löschen schützen** aktiviert.

1. Klicken Sie auf **OK**. Ihre neue Organisationseinheit wird unter Ihrer Domain angezeigt.

## Schritt 2: Erstellen eines AD-Domain-Servicekontos in Ihrem AD
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateADuser"></a>

Die Anmeldeinformationen des Domänendienstkontos werden für das Geheimnis in AWS Secrets Manager verwendet.

**So erstellen Sie ein AD-Domain-Servicekonto in Ihrem AD**

1. Öffnen Sie **Active-Directory-Benutzer und -Computer** und wählen Sie die Domain und die Organisationseinheit aus, in der Sie Ihren Benutzer erstellen möchten.

1. Klicken Sie mit der rechten Maustaste auf das Objekt **Benutzer** und wählen Sie **Neu** und dann **Benutzer** aus.

1. Geben Sie einen Vornamen, Nachnamen und Anmeldenamen für den Benutzer ein. Klicken Sie auf **Weiter**.

1. Geben Sie ein Passwort für den Benutzer ein. Wählen Sie nicht **Benutzer muss das Passwort bei der nächsten Anmeldung ändern** aus. Wählen Sie nicht **Konto ist deaktiviert** aus. Klicken Sie auf **Weiter**.

1. Klicken Sie auf **OK**. Ihr neuer Benutzer wird unter Ihrer Domain angezeigt.

## Schritt 3: Delegieren der Kontrolle an das AD-Domain-Servicekonto
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.DelegateControl"></a>

**So delegieren Sie die Kontrolle an das AD-Domain-Servicekonto in Ihrer Domain**

1. Öffnen Sie das MMC-Snap-In **Active-Directory-Benutzer und -Computer** und wählen Sie die Domain aus, in der Sie Ihren Benutzer erstellen möchten.

1. Klicken Sie mit der rechten Maustaste auf die Organisationseinheit, die Sie zuvor erstellt haben, und wählen Sie **Kontrolle delegieren** aus.

1. Klicken Sie im **Assistenten für die Delegation der Kontrolle** auf **Weiter**.

1. Klicken Sie im Abschnitt **Benutzer oder Gruppen** auf **Hinzufügen**.

1. Geben Sie im Abschnitt **Benutzer, Computer oder Gruppen auswählen** das von Ihnen erstellte AD-Domain-Servicekonto ein und klicken Sie auf **Namen überprüfen**. Wenn Ihre AD-Domain-Servicekontoprüfung erfolgreich ist, klicken Sie auf **OK**.

1. Bestätigen Sie im Abschnitt **Benutzer oder Gruppen**, dass Ihr AD-Domain-Servicekonto hinzugefügt wurde, und klicken Sie auf **Weiter**.

1. Wählen Sie im Abschnitt **Zu delegierende Aufgaben** die Option **Eine zu delegierende benutzerdefinierte Aufgabe erstellen** aus und klicken Sie auf **Weiter**.

1. Gehen Sie im Abschnitt **Active-Directory-Objekttyp** wie folgt vor:

   1. Wählen Sie **Nur die folgenden Objekte in dem Ordner** aus.

   1. Wählen Sie **Computerobjekte** aus.

   1. Wählen Sie **Ausgewählte Objekte in diesem Ordner erstellen** aus.

   1. Wählen Sie **Ausgewählte Objekte in diesem Ordner löschen** aus und klicken Sie auf **Weiter**.

1. Gehen Sie im Abschnitt **Berechtigungen** wie folgt vor:

   1. Behalten Sie die Auswahl von **Allgemein** bei.

   1. Wählen Sie **Überprüfter Schreibvorgang in den DNS-Hostnamen** aus.

   1. Wählen Sie **Überprüfter Schreibvorgang in den Service-Prinzipalnamen** aus und klicken Sie auf **Weiter**.

   1. Um die Kerberos-Authentifizierung zu aktivieren, lassen Sie die Option **Eigenschaftsspezifisch** aktiviert und wählen Sie in der Liste die Option **Schreiben servicePrincipalName** aus.

1. Überprüfen und bestätigen Sie Ihre Einstellungen unter **Den Assistenten für die Delegation der Kontrolle abschließen** und klicken Sie auf **Fertig stellen**.

1. Öffnen Sie für die Kerberos-Authentifizierung den DNS-Manager und dann die **Servereigenschaften**.

   1. Geben Sie im Windows-Dialogfeld `dnsmgmt.msc` ein.

   1. Fügen Sie das AD-Domain-Servicekonto auf der Registerkarte **Sicherheit** hinzu.

   1. Wählen Sie die Berechtigung **Lesen** aus und übernehmen Sie Ihre Änderungen.

## Schritt 4: Erstellen Sie einen Schlüssel AWS KMS
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateKMSkey"></a>

Der KMS-Schlüssel wird verwendet, um Ihr AWS Geheimnis zu verschlüsseln.

**Um einen Schlüssel zu erstellen AWS KMS**
**Anmerkung**  
 Verwenden Sie für den **Verschlüsselungsschlüssel** nicht den AWS Standard-KMS-Schlüssel. Stellen Sie sicher, dass Sie den AWS KMS Schlüssel in demselben AWS Konto erstellen, das die RDS for SQL Server-DB-Instance enthält, die Sie Ihrem selbstverwalteten AD hinzufügen möchten. 

1. Wählen Sie in der AWS KMS Konsole **Create Key** aus.

1. Wählen Sie für **Schlüsseltyp** **Symmetrisch** aus.

1. Wählen Sie für **Schlüsselnutzung** die Option **Verschlüsseln und Entschlüsseln** aus.

1. Für **Advanced options (Erweiterte Optionen)**:

   1. Wählen Sie unter **Schlüsselmaterialursprung** **KMS** aus.

   1. Wählen Sie für **Regionalität** **Single-Region-Schlüssel** aus und klicken Sie auf **Weiter**.

1. Geben Sie für **Alias** einen Namen für den KMS-Schlüssel an.

1. (Optional) Geben Sie unter **Beschreibung** eine Beschreibung des KMS-Schlüssels an.

1. (Optional) Geben Sie für **Tags** ein Tag für den KMS-Schlüssel an und klicken Sie auf **Weiter**.

1. Geben Sie für **Schlüsseladministratoren** den Namen eines IAM-Benutzers an und wählen Sie ihn aus.

1. Lassen Sie für **Schlüssellöschung** das Kontrollkästchen für **Ermöglicht Schlüsseladministratoren das Löschen dieses Schlüssels** aktiviert und klicken Sie auf **Weiter**.

1. Geben Sie für **Schlüsselbenutzer** den IAM-Benutzer aus dem vorherigen Schritt an und wählen Sie ihn aus. Klicken Sie auf **Weiter**.

1. Prüfen Sie die Konfiguration.

1. Fügen Sie für **Schlüsselrichtlinie** Folgendes zur Richtlinien-**Anweisung** hinzu:

   ```
   {
       "Sid": "Allow use of the KMS key on behalf of RDS",
       "Effect": "Allow",
       "Principal": {
           "Service": [
               "rds.amazonaws.com"
           ]
       },
       "Action": "kms:Decrypt",
       "Resource": "*"
   }
   ```

1. Klicken Sie auf **Beenden**.

## Schritt 5: Erstellen Sie ein AWS Geheimnis
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateSecret"></a>

**So erstellen Sie ein Secret**
**Anmerkung**  
 Stellen Sie sicher, dass Sie das Geheimnis in demselben AWS Konto erstellen, das die RDS for SQL Server-DB-Instance enthält, die Sie Ihrem selbstverwalteten AD hinzufügen möchten. 

1. Wählen Sie im AWS Secrets Manager die Option **Neues Geheimnis speichern** aus.

1. Als **Secret-Typ** wählen Sie **Anderer Secret-Typ** aus.

1. Fügen Sie für **Schlüssel/Wert-Paare** Ihre beiden Schlüssel hinzu:

   1. Geben Sie als ersten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_USERNAME` ein.

   1. Geben Sie als Wert für den ersten Schlüssel nur den Benutzernamen (ohne das Domain-Präfix) des AD-Benutzers ein. Geben Sie den Domain-Namen nicht an, da dies dazu führt, dass die Instance-Erstellung fehlschlägt.

   1. Geben Sie als zweiten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_PASSWORD` ein.

   1. Geben Sie als Wert des zweiten Schlüssels das Passwort ein, das Sie für den AD-Benutzer in Ihrer Domain erstellt haben.

1. Geben Sie als **Verschlüsselungsschlüssel** den KMS-Schlüssel ein, den Sie in einem vorherigen Schritt erstellt haben, und klicken Sie auf **Weiter**.

1. Geben Sie als **Secret-Name** einen aussagekräftigen Namen ein, anhand dessen Sie das Secret später leichter finden können.

1. (Optional) Geben Sie im Feld **Beschreibung** eine Beschreibung für den Secret-Namen ein.

1. Klicken Sie unter **Ressourcenberechtigung** auf **Bearbeiten**.

1. Fügen Sie der Berechtigungsrichtlinie folgende Richtlinie hinzu:
**Anmerkung**  
Wir empfehlen Ihnen, die `aws:sourceAccount` und `aws:sourceArn` Bedingungen in der Police zu verwenden, um das Problem des *verwirrten Vertreters* zu vermeiden. Verwenden Sie Ihre AWS-Konto für `aws:sourceAccount` und die RDS for SQL Server-DB-Instance ARN für`aws:sourceArn`. Weitere Informationen finden Sie unter [Vermeidung des dienstübergreifenden Confused-Deputy-Problems](cross-service-confused-deputy-prevention.md).

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement":
       [
           {
               "Effect": "Allow",
               "Principal":
               {
                   "Service": "rds.amazonaws.com"
               },
               "Action": "secretsmanager:GetSecretValue",
               "Resource": "*",
               "Condition":
               {
                   "StringEquals":
                   {
                       "aws:sourceAccount": "123456789012"
                   },
                   "ArnLike":
                   {
                       "aws:sourceArn": "arn:aws:rds:us-west-2:123456789012:db:*"
                   }
               }
           }
       ]
   }
   ```

------

1. Klicken Sie auf **Speichern** und dann auf **Weiter**.

1. Behalten Sie für **Rotationseinstellungen konfigurieren** die Standardwerte bei und wählen Sie **Weiter** aus.

1. Überprüfen Sie die Einstellungen für das Secret und klicken Sie auf **Speichern**.

1. Wählen Sie das von Ihnen erstellte Secret aus und kopieren Sie den Wert für den **Secret-ARN**. Dieser wird im nächsten Schritt bei der Einrichtung des selbstverwalteten Active Directory verwendet.

# Hinzufügen Ihrer DB-Instance zu Ihrem selbstverwalteten Active Directory
<a name="USER_SQLServer_SelfManagedActiveDirectory.Joining"></a>

Gehen Sie wie folgt vor, um Ihre DB-Instance von RDS für SQL Server zu Ihrem selbstverwalteten AD hinzuzufügen:

## Schritt 1: Erstellen oder Ändern einer SQL Server-DB-Instance
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateModify"></a>

Sie können die Konsole, die CLI oder die RDS-API verwenden, um eine RDS-für- SQL-Server-DB-Instance mit einer selbstverwalteten AD-Domain zu verknüpfen. Sie können dafür eine der folgenden Möglichkeiten auswählen:
+ Erstellen Sie mit der Konsole, dem [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)CLI-Befehl oder dem Vorgang [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API eine neue SQL Server-DB-Instance.

  Detaillierte Anweisungen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ändern Sie eine vorhandene SQL Server-DB-Instance mithilfe der Konsole, des [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI-Befehls oder der Operation [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API.

  Detaillierte Anweisungen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Stellen Sie mithilfe der Konsole, des CLI-Befehls -db-snapshot oder des API-Vorgangs Restore From DBSnapshot RDS eine SQL [restore-db-instance-fromServer-DB-Instance DBInstance aus einem DB-Snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) [wieder her](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html).

  Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance point-in-time mithilfe der Konsole, des Befehls [restore-db-instance-to- point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) CLI oder der Operation [Restore DBInstance ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API in einer wieder her.

  Detaillierte Anweisungen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).

Wenn Sie den verwenden AWS CLI, sind die folgenden Parameter erforderlich, damit die DB-Instance die von Ihnen erstellte selbstverwaltete AD-Domäne verwenden kann:
+ Verwenden Sie für den Parameter `--domain-fqdn` den vollständig qualifizierten Domain-Namen (FQDN) Ihres selbstverwalteten AD.
+ Verwenden Sie für den Parameter `--domain-ou` die Organisationseinheit, die Sie in Ihrem selbstverwalteten AD erstellt haben.
+ Verwenden Sie für den Parameter `--domain-auth-secret-arn` den Wert des **Secret-ARN**, den Sie in einem vorherigen Schritt erstellt haben.
+ Verwenden Sie für den `--domain-dns-ips` Parameter die primären und sekundären IPv4 Adressen der DNS-Server für Ihr selbstverwaltetes AD. Wenn Sie keine sekundäre DNS-Server-IP-Adresse haben, geben Sie die primäre IP-Adresse zweimal ein.

Die folgenden CLI-Beispielbefehle zeigen, wie Sie eine RDS-für-SQL-Server-DB-Instance mit einer selbstverwalteten AD-Domain erstellen, ändern und entfernen.

**Wichtig**  
Wenn Sie eine DB-Instance ändern, um sie einer selbstverwalteten AD-Domain hinzuzufügen oder aus dieser zu entfernen, ist ein Neustart der DB-Instance erforderlich, damit die Änderung wirksam wird. Sie können wählen, ob Sie die Änderungen sofort übernehmen oder bis zum nächsten Wartungsfenster warten möchten. Wenn Sie die Option **Sofort anwenden** auswählen, führt dies bei einer Single-AZ-DB-Instance zu Ausfallzeiten. Eine Multi-AZ-DB-Instance führt ein Failover durch, bevor ein Neustart ausgeführt wird. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md). 

Mit dem folgenden CLI-Befehl wird eine neue RDS-für-SQL-Server-DB-Instance erstellt und einer selbstverwalteten AD-Domain hinzugefügt.

Für Linux, macOS oder Unix:

```
aws rds create-db-instance \
    --db-instance-identifier my-DB-instance \
    --db-instance-class db.m5.xlarge \
    --allocated-storage 50 \
    --engine sqlserver-se \
    --engine-version 15.00.4043.16.v1 \
    --license-model license-included \
    --master-username my-master-username \
    --master-user-password my-master-password \
    --domain-fqdn my_AD_domain.my_AD.my_domain \
    --domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain \
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \
    --domain-dns-ips "10.11.12.13" "10.11.12.14"
```

Für Windows:

```
aws rds create-db-instance ^
    --db-instance-identifier my-DB-instance ^
    --db-instance-class db.m5.xlarge ^
    --allocated-storage 50 ^
    --engine sqlserver-se ^
    --engine-version 15.00.4043.16.v1 ^
    --license-model license-included ^
    --master-username my-master-username ^
    --master-user-password my-master-password ^
    --domain-fqdn my-AD-test.my-AD.mydomain ^
    --domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain ^
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \ ^
    --domain-dns-ips "10.11.12.13" "10.11.12.14"
```

Mit dem folgenden CLI-Befehl wird eine vorhandene DB-Instance von RDS für SQL Server, so geändert, dass sie eine selbstverwaltete AD-Domain verwendet.

Für Linux, macOS oder Unix:

```
aws rds modify-db-instance \
    --db-instance-identifier my-DB-instance \
    --domain-fqdn my_AD_domain.my_AD.my_domain \
    --domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain \
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \ 
    --domain-dns-ips "10.11.12.13" "10.11.12.14"
```

Für Windows:

```
aws rds modify-db-instance ^
    --db-instance-identifier my-DBinstance ^
    --domain-fqdn my_AD_domain.my_AD.my_domain ^
    --domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain ^
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" ^ 
    --domain-dns-ips "10.11.12.13" "10.11.12.14"
```

Mit dem folgenden CLI-Befehl wird eine DB-Instance von RDS für SQL Server aus einer selbstverwalteten AD-Domain entfernt.

Für Linux, macOS oder Unix:

```
aws rds modify-db-instance \
    --db-instance-identifier my-DB-instance \
    --disable-domain
```

Für Windows:

```
aws rds modify-db-instance ^
    --db-instance-identifier my-DB-instance ^
    --disable-domain
```

## Schritt 2: Verwenden der Kerberos- oder NTLM-Authentifizierung
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.KerbNTLM"></a>

### NTLM-Authentifizierung
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.KerbNTLM.NTLM"></a>

Jede DB-Instance von Amazon RDS hat einen Endpunkt und jeder Endpunkt hat einen DNS-Namen und eine Portnummer für die DB-Instance. Um eine Verbindung mir Ihrer DB-Instance mit einer SQL-Client-Anwendung herzustellen, benötigen Sie den DNS-Namen und die Portnummer für Ihre DB-Instance. Um sich mithilfe der NTLM-Authentifizierung zu authentifizieren, müssen Sie eine Verbindung zum RDS-Endpunkt oder zum Listener-Endpunkt herstellen, wenn Sie eine Multi-AZ-Bereitstellung verwenden.

Während einer geplanten Datenbankwartung oder einer ungeplanten Serviceunterbrechung führt Amazon RDS automatisch einen Failover zur up-to-date sekundären Datenbank durch, sodass der Betrieb schnell und ohne manuelles Eingreifen wieder aufgenommen werden kann. Die primären und sekundären Instances verwenden denselben Endpunkt, dessen physische Netzwerkadresse als Teil des Failover-Prozesses an das sekundäre Replikat übergeben wird. Sie müssen Ihre Anwendung nicht neu konfigurieren, wenn ein Failover auftritt.

### Kerberos-Authentifizierung
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.Kerb"></a>

Für die Kerberos-basierte Authentifizierung für RDS für SQL Server müssen Verbindungen zu einem bestimmten Service-Prinzipalnamen (SPN) hergestellt werden. Nach einem Failover-Ereignis ist der Anwendung der neue SPN jedoch möglicherweise nicht bekannt. Um dieses Problem zu lösen, bietet RDS für SQL Server einen Kerberos-basierten Endpunkt.

Der Kerberos-basierte Endpunkt folgt einem bestimmten Format. Wenn Ihr RDS-Endpunkt `rds-instance-name.account-region-hash.aws-region.rds.amazonaws.com` ist, wäre `rds-instance-name.account-region-hash.aws-region.awsrds.fully qualified domain name (FQDN)` der entsprechende Kerberos-basierte Endpunkt.

Wenn der RDS-Endpunkt beispielsweise `ad-test.cocv6zwtircu.us-east-1.rds.amazonaws.com` ist und der Domain-Name `corp-ad.company.com` lautet, wäre der Kerberos-basierte Endpunkt `ad-test.cocv6zwtircu.us-east-1.awsrds.corp-ad.company.com`.

Dieser Kerberos-basierte Endpunkt kann zur Authentifizierung bei der SQL-Server-Instance mithilfe von Kerberos verwendet werden, auch nach einem Failover-Ereignis, da der Endpunkt automatisch aktualisiert wird, sodass er auf den neuen SPN der primären SQL-Server-Instance verweist.

### Auffinden Ihres CNAME
<a name="USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CNAME"></a>

Um Ihren CNAME zu finden, stellen Sie eine Verbindung zu Ihrem Domain-Controller her und öffnen Sie den **DNS-Manager**. Navigieren Sie zu **Forward-Lookup-Zonen** und Ihrem FQDN.

Navigieren Sie durch **awsrds**, **aws-region** und **account and region specific hash**.

![\[Ändern der Speichermenge einer DB-Instance\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/kerb-endpoint-selfManagedAD-RDSMS.png)


Wenn nach der Verbindung mit CNAME vom Remote-Client aus eine NTLM-Verbindung zurückgegeben wird, überprüfen Sie, ob die erforderlichen Ports auf der Zulassungsliste stehen.

Wenn Sie überprüfen möchten, ob Ihre Verbindung Kerberos verwendet, führen Sie die folgende Abfrage aus:

```
SELECT net_transport, auth_scheme
    FROM sys.dm_exec_connections
    WHERE session_id = @@SSPID;
```

Wenn Ihre Instance beim Herstellen einer Verbindung zu einem Kerberos-Endpunkt eine NTLM-Verbindung zurückgibt, überprüfen Sie Ihre Netzwerk- und Benutzerkonfigurationen. Siehe [Konfigurieren Ihrer Netzwerkkonnektivität](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig).

## Schritt 3: SQL Server-Logins für die Windows-Authentifizierung erstellen
<a name="USER_SQLServer_SelfManagedActiveDirectory.CreateLogins"></a>

Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Masterbenutzer, um eine Verbindung zur SQL-Server-DB-Instance herzustellen, wie Sie es bei jeder anderen DB-Instance tun würden. Da die DB-Instance der selbstverwalteten AD-Domain hinzugefügt wurde, können Sie SQL-Server-Anmeldungen und -Benutzer bereitstellen. Sie tun dies über das AD-Dienstprogramm für Benutzer und Gruppen in Ihrer selbstverwalteten AD-Domain. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.

Damit sich ein Domain-Servicekonto eines selbstverwalteten AD mit SQL Server authentifizieren kann, muss eine Windows-Anmeldung für SQL Server für das Domain-Servicekonto des selbstverwalteten AD oder für eine Gruppe des selbstverwalteten AD, der der Benutzer angehört, vorliegen. Eine differenzierte Zugriffskontrolle wird durch das Gewähren und Widerrufen von Berechtigungen für diese SQL Server-Anmeldungen gewährleistet. Ein Domain-Servicekonto des selbstverwalteten AD, das über keine SQL-Server-Anmeldung verfügt oder zu keiner Gruppe des selbstverwalteten AD mit einer solchen Anmeldung gehört, kann nicht auf die DB-Instance von SQL Server zugreifen.

Die Berechtigung ALTER ANY LOGIN ist erforderlich, um eine SQL-Server-Anmeldung für das selbstverwaltete AD zu erstellen. Wenn Sie mit dieser Berechtigung noch keine Anmeldungen erstellt haben, verbinden Sie sich mithilfe der SQL-Server-Authentifizierung als Masterbenutzer der DB-Instance und erstellen Sie Ihre SQL-Server-Anmeldungen für das selbstverwaltete AD im Kontext des Masterbenutzers.

Sie können einen Data Definition Language (DDL)-Befehl wie im Folgenden dargestellt ausführen, um eine SQL-Server-Anmeldung für ein Domain-Servicekonto des selbstverwalteten AD oder eine entsprechende Gruppe zu erstellen.

**Anmerkung**  
Geben Sie Benutzer und Gruppen unter Verwendung des Anmeldenamens von Windows 2000 im Format a `my_AD_domain\my_AD_domain_user`. Sie können keinen User Principle Name (UPN) im Format verwenden *`my_AD_domain_user`*`@`*`my_AD_domain`*.

```
USE [master]
GO
CREATE LOGIN [my_AD_domain\my_AD_domain_user] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO
```

Weitere Informationen finden Sie unter [ANMELDENAME ERSTELLEN (Transact-SQL)](https://msdn.microsoft.com/en-us/library/ms189751.aspx) in der Microsoft Developer Network-Dokumentation.

Benutzer (sowohl menschliche Benutzer als auch Anwendungen) aus Ihrer Domain können sich nun von einem einer selbstverwalteten AD-Domain hinzugefügten Client-Computer mithilfe der Windows-Authentifizierung mit der RDS-für-SQL-Server-Instance verbinden.

# Verwalten einer DB-Instance in einer selbstverwalteten Active-Directory-Domain
<a name="USER_SQLServer_SelfManagedActiveDirectory.Managing"></a>

 Sie können die Konsole oder die Amazon RDS-API verwenden AWS CLI, um Ihre DB-Instance und ihre Beziehung zu Ihrer selbstverwalteten AD-Domain zu verwalten. Beispielsweise können Sie die DB-Instance in Domänen, aus Domänen oder zwischen Domänen verschieben. 

 Sie können z. B. mithilfe der Amazon-RDS-API Folgendes tun: 
+ Um aufgrund einer fehlgeschlagenen Mitgliedschaft erneut zu versuchen, einer selbstverwalteten Domain beizutreten, verwenden Sie den Vorgang „DBInstanceAPI [ändern](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)“ und geben Sie dieselben Parameter an:
  + `--domain-fqdn`
  + `--domain-dns-ips`
  + `--domain-ou`
  + `--domain-auth-secret-arn`
+ Um eine DB-Instance aus einer selbstverwalteten Domain zu entfernen, verwenden Sie die API-Operation `ModifyDBInstance` und geben Sie `--disable-domain` als Domain-Parameter an.
+ Um eine DB-Instance von einer selbstverwalteten Domain in eine andere zu verschieben, verwenden Sie die API-Operation `ModifyDBInstance` und geben Sie die Domain-Parameter für die neue Domain an:
  + `--domain-fqdn`
  + `--domain-dns-ips`
  + `--domain-ou`
  + `--domain-auth-secret-arn`
+ [Verwenden Sie den Vorgang Describe API, um die selbstverwaltete AD-Domänenmitgliedschaft für jede DB-Instance aufzulisten. DBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html)

## Grundlegendes zur Mitgliedschaft in einer selbstverwalteten Active-Directory-Domain
<a name="USER_SQLServer_SelfManagedActiveDirectory.Understanding"></a>

Nachdem Sie Ihre DB-Instance erstellt oder geändert und dabei AD-Details angegeben haben, wird die Instance ein Mitglied der selbstverwalteten AD-Domain. Die AWS Konsole zeigt den Status der selbstverwalteten Active Directory-Domänenmitgliedschaft für die DB-Instance an. Der Status der DB-Instance kann einer der folgenden sein: 
+  **joined** – Die Instance ist Mitglied der AD-Domain.
+  **joining** – Die Instance ist gerade dabei, Mitglied der AD-Domain zu werden.
+  **pending-join** – Die Mitgliedschaft der Instance steht noch aus.
+  **pending-maintenance-join**— versucht, AWS die Instance während des nächsten geplanten Wartungsfensters zu einem Mitglied der AD-Domäne zu machen.
+  **pending-removal** – Das Entfernen der Instance von der AD-Domain steht noch aus.
+  **pending-maintenance-removal**— versucht, AWS die Instanz während des nächsten geplanten Wartungsfensters aus der AD-Domäne zu entfernen.
+  **failed** – Ein Konfigurationsproblem hat verhindert, dass die Instance der Domain beitreten konnte. Überprüfen und korrigieren Sie Ihre Konfiguration, bevor Sie den Befehl zu Änderung der Instance erneut ausführen.
+  **removing** – Die Instance wird gerade von der selbstverwalteten AD-Domain entfernt.

**Wichtig**  
Eine Anfrage, Mitglied einer selbstverwalteten AD-Domain zu werden, kann wegen eines Netzwerkverbindungsproblems fehlschlagen. Es könnte beispielsweise sein, dass Sie eine DB-Instance erstellen oder eine vorhandene Instance ändern und der Versuch, die DB-Instance zu einem Mitglied einer selbstverwalteten AD-Domain zu machen, fehlschlägt. Geben Sie in diesem Fall entweder den Befehl zum Erstellen oder Ändern der DB-Instance neu aus oder ändern Sie die neu erstellte Instance, damit sie der selbstverwalteten AD-Domain beitreten kann.

# Fehlerbehebung für selbstverwaltetes Active Directory
<a name="USER_SQLServer_SelfManagedActiveDirectory.TroubleshootingSelfManagedActiveDirectory"></a>

Die folgenden Probleme können auftreten, wenn Sie ein selbstverwaltetes AD einrichten oder ändern.


****  

| Fehlercode | Description | Häufige Ursachen | Vorschläge für die Fehlerbehebung | 
| --- | --- | --- | --- | 
| Fehler 2 / 0x2 | Die angegebene Datei wurde nicht gefunden. | Das Format oder der Speicherort für die Organisationseinheit, das/der mit dem Parameter `—domain-ou` angegeben wurde, ist ungültig. Das über AWS Secrets Manager angegebene Domänendienstkonto verfügt nicht über die erforderlichen Berechtigungen, um der Organisationseinheit beizutreten. | Überprüfen Sie den Parameter `—domain-ou`. Stellen Sie sicher, dass das Domain-Servicekonto über die richtigen Berechtigungen für die Organisationseinheit verfügt. Weitere Informationen finden Sie unter [Konfigurieren Ihres AD-Domain-Servicekontos](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig).  | 
| Fehler 5 / 0x5 | Zugriff verweigert. | Falsch konfigurierte Berechtigungen für das Domain-Servicekonto oder das Computerkonto ist bereits in der Domain vorhanden. | Überprüfen Sie die Berechtigungen des Domain-Servicekontos in der Domain und stellen Sie sicher, dass das RDS-Computerkonto nicht doppelt in der Domain vorhanden ist. Sie können den Namen des RDS-Computerkontos überprüfen, indem Sie `SELECT @@SERVERNAME` auf Ihrer RDS-für-SQL-Server-DB-Instance ausführen. Versuchen Sie bei Verwendung von Multi-AZ, einen Neustart mit Failover durchzuführen, und überprüfen Sie dann das RDS-Computerkonto erneut. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md). | 
| Fehler 87 / 0x57 | Der Parameter ist falsch. | Das über AWS Secrets Manager angegebene Domänendienstkonto verfügt nicht über die richtigen Berechtigungen. Auch das Benutzerprofil ist möglicherweise beschädigt. | Prüfen Sie die Anforderungen für das Domain-Servicekonto. Weitere Informationen finden Sie unter [Konfigurieren Ihres AD-Domain-Servicekontos](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig).  | 
| Fehler 234 / 0xEA | Die angegebene Organisationseinheit ist nicht vorhanden. | Die mit dem Parameter `—domain-ou` angegebene Organisationseinheit ist in Ihrem selbstverwalteten AD nicht vorhanden. | Überprüfen Sie den Parameter `—domain-ou` und stellen Sie sicher, dass die angegebene Organisationseinheit in Ihrem selbstverwalteten AD vorhanden ist. | 
| Fehler 1326 / 0x52E | Der Benutzername oder das Passwort ist falsch. | Die in AWS Secrets Manager angegebenen Anmeldeinformationen für das Domänendienstkonto enthalten einen unbekannten Benutzernamen oder ein falsches Passwort. Möglicherweise ist das Domain-Konto auch in Ihrem selbstverwalteten AD deaktiviert. | Stellen Sie sicher, dass die in AWS Secrets Manager angegebenen Anmeldeinformationen korrekt sind und das Domain-Konto in Ihrem selbstverwalteten AD aktiviert ist. | 
| Fehler 1355 / 0x54B | Die angegebene Domain ist nicht vorhanden oder konnte nicht kontaktiert werden. | Die Domain ist ausgefallen, der angegebene IPs DNS-Satz ist nicht erreichbar oder der angegebene FQDN ist nicht erreichbar. | Stellen Sie sicher, dass die Parameter `—domain-dns-ips` und `—domain-fqdn` korrekt sind. Überprüfen Sie die Netzwerkkonfiguration Ihrer RDS-für-SQL-Server-DB-Instance und stellen Sie sicher, dass Ihr selbstverwaltetes AD erreichbar ist. Weitere Informationen finden Sie unter [Konfigurieren Ihrer Netzwerkkonnektivität](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig).  | 
| Fehler 1722 / 0x6BA | Der RPC-Server ist nicht verfügbar. | Der RPC-Service Ihrer AD-Domain konnte nicht erreicht werden. Dies könnte auf einen Service- oder Netzwerkfehler zurückzuführen sein. | Stellen Sie sicher, dass der RPC-Service auf Ihren Domain-Controllern ausgeführt wird und dass die TCP-Ports `135` und `49152-65535` in Ihrer Domain von Ihrer RDS-für-SQL -Server-DB-Instance aus erreichbar sind. | 
|  Fehler 1727 / 0x6BF  |  Der Remote-Prozeduraufruf ist fehlgeschlagen und wurde nicht ausgeführt.  |  Netzwerkverbindungsproblem oder Firewall-Einschränkung blockiert die RPC-Kommunikation mit dem Domain-Controller.  |  Wenn Sie den VPC-übergreifenden Domain-Beitritt verwenden, überprüfen Sie, ob die VPC-übergreifende Kommunikation korrekt mit VPC-Peering oder Transit Gateway eingerichtet ist. Stellen Sie sicher, dass die hohen TCP-Ports `49152-65535` in Ihrer Domain von Ihrer DB-Instance von RDS für SQL Server aus erreichbar sind, einschließlich aller möglichen Firewall-Einschränkungen.  | 
| Fehler 2224 / 0x8B0 | Das Benutzerkonto besteht bereits. | Das Computerkonto, das zu Ihrem selbstverwalteten AD hinzugefügt werden soll, ist bereits vorhanden. | Ermitteln Sie das Computerkonto, indem Sie `SELECT @@SERVERNAME` auf Ihrer RDS-für-SQL-Server-DB-Instance ausführen, und entfernen Sie es dann vorsichtig aus Ihrem selbstverwalteten AD. | 
| Fehler 2242 / 0x8c2 | Das Passwort dieses Benutzers ist abgelaufen. | Das Passwort für das über AWS Secrets Manager angegebene Domänendienstkonto ist abgelaufen. | Aktualisieren Sie das Passwort für das Domain-Servicekonto, über das Sie Ihre RDS-für-SQL-Server-DB-Instance Ihrem selbstverwalteten AD hinzufügen. | 

Nachdem Sie Ihre DB-Instance zu einer selbstverwalteten Active-Directory-Domain hinzugefügt haben, erhalten Sie möglicherweise RDS-Ereignisse, die sich auf den Zustand Ihrer Domain beziehen.

```
Unhealthy domain state detected while attempt to verify or 
configure your Kerberos endpoint in your domain on 
node node_n. message
```

Bei Multi-AZ-Instances stellen Sie möglicherweise die Fehlerberichterstattung sowohl für Knoten1 als auch Knoten2 fest, was darauf hindeutet, dass die Kerberos-Konfiguration Ihrer Instance nicht für einen Failover bereit ist. Im Falle eines Failovers können Probleme bei der Authentifizierung mit Kerberos auftreten. Beheben Sie die Konfigurationsprobleme, um sicherzustellen, dass die Kerberos-Einrichtung gültig und aktuell ist. Bei Multi-AZ-Instances sind keine Aktionen erforderlich, um die Kerberos-Authentifizierung auf dem neuen primären Host zu verwenden, sofern alle Netzwerk- und Berechtigungskonfigurationen vorhanden sind.

Bei Single-AZ-Instances ist Knoten1 der Primärknoten. Wenn Ihre Kerberos-Authentifizierung nicht wie erwartet funktioniert, überprüfen Sie die Instance-Ereignisse und beheben Sie die Konfigurationsprobleme, um sicherzustellen, dass die Kerberos-Einrichtung gültig und aktuell ist.

## Wiederherstellen einer SQL-Server-DB-Instance und Hinzufügen zu einer selbstverwalteten Active-Directory-Domain
<a name="USER_SQLServer_SelfManagedActiveDirectory.Restore"></a>

Sie können einen DB-Snapshot wiederherstellen oder eine point-in-time Wiederherstellung (PITR) für eine SQL Server-DB-Instance durchführen und sie dann einer selbstverwalteten Active Directory-Domäne hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, ändern Sie die Instance, indem Sie den unter [Schritt 1: Erstellen oder Ändern einer SQL Server-DB-Instance](USER_SQLServer_SelfManagedActiveDirectory.Joining.md#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateModify) beschriebenen Prozess anwenden, um die DB-Instance einer selbstverwalteten AD-Domain hinzuzufügen.

# Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server
<a name="USER_SQLServerWinAuth"></a>

Sie können AWS Managed Microsoft AD es verwenden, um Benutzer mit der Windows-Authentifizierung zu authentifizieren, wenn sie eine Verbindung zu Ihrer RDS for SQL Server-DB-Instance herstellen. Die DB-Instance funktioniert mit AWS Directory Service for Microsoft Active Directory, wird auch genannt AWS Managed Microsoft AD, um die Windows-Authentifizierung zu aktivieren. Wenn Benutzer sich mit einer SQL Server-DB-Instance authentifizieren, die mit einer vertrauenswürdigen Domäne verbunden ist, werden die Authentifizierungsanfragen an das Domänenverzeichnis weitergeleitet, das Sie mit erstellt habe Directory Service. 

## Verfügbarkeit von Regionen und Versionen
<a name="USER_SQLServerWinAuth.RegionVersionAvailability"></a>

Amazon RDS unterstützt nur die Verwendung AWS Managed Microsoft AD für die Windows-Authentifizierung. RDS unterstützt die Verwendung nicht AD Connector. Weitere Informationen finden Sie unter:
+ [Richtlinie zur Anwendungskompatibilität für AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_app_compatibility.html)
+ [Richtlinie zur Anwendungskompatibilität für AD-Connector](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ad_connector_app_compatibility.html)

Informationen zur Versions- und Regionsverfügbarkeit finden Sie unter [Kerberos-Authentifizierung mit RDS für SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.sq).

## Übersicht zur Einrichtung einer Windows-Authentifizierung
<a name="USER_SQLServerWinAuth.overview"></a>

Amazon RDS verwendet einen gemischten Modus für die Windows-Authentifizierung. Mit dieser Vorgehensweise verwendet der *Hauptbenutzer* (zum Erstellen der SQL Server-DB-Instance verwendeter Name und verwendetes Passwort ) die SQL-Authentifizierung. Da das Masterbenutzerkonto Anmeldedaten mit besonderen Berechtigungen enthält, sollte der Zugriff auf dieses Konto beschränkt sein.

Um mithilfe eines lokalen oder selbst gehosteten Microsoft Active Directory Windows-Authentifizierung abzurufen, erstellen Sie eine Gesamtstruktur-Vertrauensstellung. Die Vertrauensstellung kann uni- oder bidirektional sein. Weitere Informationen zum Einrichten von Forest Trusts mithilfe von Directory Service finden Sie unter [Wann sollte eine Vertrauensstellung erstellt werden?](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_setup_trust.html) im *AWS Directory Service Administratorhandbuch*.

Führen Sie die folgenden Schritte aus, um eine Windows-Authentifizierung für eine SQL Server-DB-Instance einzurichten. Diese Schritt werden unter noch genauer erklär [Einrichten einer Windows-Authentifizierung für SQL Server-DB-Instances](USER_SQLServerWinAuth.SettingUp.md):

1. Verwenden Sie AWS Managed Microsoft AD entweder über die AWS-Managementkonsole oder die Directory Service API, um ein AWS Managed Microsoft AD Verzeichnis zu erstellen. 

1. Wenn Sie die AWS CLI oder Amazon RDS-API verwenden, um Ihre SQL Server-DB-Instance zu erstellen, erstellen Sie eine AWS Identity and Access Management (IAM-) Rolle. Diese Rolle verwendet die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` und ermöglicht es Amazon RDS, Aufrufe an Ihr Verzeichnis durchzuführen. Wenn Sie die Konsole zum Erstellen der SQL Server-DB-Instance verwenden, erstellt AWS die IAM-Rolle für Sie. 

   Damit die Rolle Zugriff gewährt, muss der Endpunkt AWS -Security-Token-Service (AWS STS) in der AWS Region für Ihr AWS Konto aktiviert sein. AWS STS Endpunkte sind standardmäßig in allen AWS Regionen aktiv, und Sie können sie ohne weitere Aktionen verwenden. Weitere Informationen finden Sie unter [Verwalten von AWS STS in einer AWS-Region](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) im *IAM-Benutzerhandbuch*.

1. Erstellen und konfigurieren Sie Benutzer und Gruppen im AWS Managed Microsoft AD Verzeichnis mithilfe der Microsoft Active Directory-Tools. Weitere Informationen zum Erstellen von Benutzern und Gruppen in Ihrem Active Directory finden Sie unter [Verwalten von Benutzern und Gruppen in AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html) im *AWS Directory Service Administrationshanbuch*.

1. Wenn Sie planen, das Verzeichnis und die DB-Instance an unterschiedlichen Orten zu lokalisieren VPCs, aktivieren Sie den vPC-übergreifenden Verkehr.

1. Verwenden Sie Amazon RDS, um eine neue SQL Server-DB-Instance entweder über die Konsole oder über die Amazon RDS-API zu erstellen. AWS CLI In der Anforderung zum Erstellen geben Sie den Domänenbezeichner an ("`d-*`"-Bezeichner), der beim Erstellen des Verzeichnisses generiert wurde, sowie den Namen der von Ihnen erstellten Rolle. Sie können auch eine vorhandene SQL Server-DB-Instance für die Verwendung der Windows-Authentifizierung ändern, indem Sie die Domänen- und IAM-Rollenparameter für die DB-Instance festlegen.

1. Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Hauptbenutzer, um eine Verbindung zur SQL Server-DB-Instance herzustellen, wie Sie es bei jeder anderen DB-Instance tun würden. Da die DB-Instance mit der AWS Managed Microsoft AD Domäne verbunden ist, können Sie SQL Server-Logins und Benutzer aus den Active Directory-Benutzern und -Gruppen in ihrer Domäne bereitstellen. (Diese werden als SQL Server "Windows"-Anmeldungen bezeichnet.) Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden. 

Wenn Sie mithilfe der Amazon RDS-Konsole eine mit einer Domäne verbundene RDS for SQL Server-DB-Instance erstellen, AWS wird automatisch die `rds-directoryservice-access-role` IAM-Rolle erstellt. Diese Rolle ist für die Verwaltung von mit Domains verknüpften Instances unerlässlich und für die folgenden Operationen erforderlich:
+ Vornehmen von Konfigurationsänderungen an mit einer Domain verknüpften SQL-Server-Instances
+ Verwalten der Active-Directory-Integrationseinstellungen
+ Durchführen von Wartungsvorgängen auf mit Domains verknüpften Instances

**Wichtig**  
Wenn Sie die IAM-Rolle `rds-directoryservice-access-role` löschen, können Sie über die Amazon-RDS-Konsole oder -API keine Änderungen mehr an Ihrer mit der Domain verknüpften SQL-Server-Instance vornehmen. Der Versuch, die Instance zu ändern, führt zu einer Fehlermeldung, die besagt: You don't have permission to iam:. CreateRole Um Zugriff anzufordern, kopieren Sie den folgenden Text und senden Sie ihn an Ihren AWS Administrator.  
Dieser Fehler tritt auf, weil Amazon RDS die Rolle zur Verwaltung der Domain-Verbindung neu erstellen muss, aber nicht über die erforderlichen Berechtigungen verfügt. Außerdem ist dieser Fehler nicht angemeldet CloudTrail, was die Fehlerbehebung erschweren kann.

Wenn Sie die `rds-directoryservice-access-role` versehentlich löschen, müssen Sie über die Berechtigung `iam:CreateRole` verfügen, um sie neu zu erstellen, bevor Sie Änderungen an Ihrer mit der Domain verknüpften SQL-Server-Instance vornehmen können. Um die Rolle manuell neu zu erstellen, vergewissern Sie sich, dass ihr die verwaltete Richtlinie `AmazonRDSDirectoryServiceAccess` und die entsprechende Vertrauensstellung zugeordnet sind, damit der RDS-Service die Rolle übernehmen kann.

# Erstellen des Endpunkts für die Kerberos-Authentifizierung
<a name="USER_SQLServerWinAuth.KerberosEndpoint"></a>

Eine Kerberos-basierte Authentifizierung erfordert, dass der Endpunkt ein kundendefinierter Hostname, ein Zeitraum und dann der vollständig qualifizierte Domänenname (FQDN) ist. Im Folgenden sehen Sie ein Beispiel für einen Endpunkt, den Sie mit Kerberos-basierter Authentifizierung verwenden können. In diesem Beispiel lautet der Hostname der SQL Server-DB-Instance `ad-test` und der Domänenname `corp-ad.company.com`. 

```
ad-test.corp-ad.company.com
```

Wenn Sie überprüfen möchten, ob Ihre Verbindung Kerberos verwendet, führen Sie die folgende Abfrage aus: 

```
1. SELECT net_transport, auth_scheme 
2.   FROM sys.dm_exec_connections 
3.  WHERE session_id = @@SPID;
```

# Einrichten einer Windows-Authentifizierung für SQL Server-DB-Instances
<a name="USER_SQLServerWinAuth.SettingUp"></a>

Sie verwenden AWS Directory Service for Microsoft Active Directory, auch genannt AWS Managed Microsoft AD, um die Windows-Authentifizierung für eine SQL Server-DB-Instance einzurichten. Um die Windows-Authentifizierung einzurichten, führen Sie folgende Schritte aus. 

## Schritt 1: Erstellen Sie ein Verzeichnis mit dem AWS Directory Service for Microsoft Active Directory
<a name="USER_SQLServerWinAuth.SettingUp.CreateDirectory"></a>

Directory Service erstellt ein vollständig verwaltetes Microsoft Active Directory in der AWS Cloud. Wenn Sie ein AWS Managed Microsoft AD Verzeichnis erstellen, Directory Service erstellt in Ihrem Namen zwei Domänencontroller und DNS-Server (Domain Name Service). Die Verzeichnis-Server werden in zwei Subnetzen in zwei verschiedenen Availability Zones in einer VPC erstellt. Diese Redundanz hilft sicherzustellen, dass Ihr Verzeichnis verfügbar bleibt, auch wenn ein Fehler auftritt.

 Wenn Sie ein AWS Managed Microsoft AD Verzeichnis erstellen, Directory Service führt er in Ihrem Namen die folgenden Aufgaben aus: 
+ Richtet ein Microsoft Active Directory in der VPC ein. 
+ Erstellt ein Verzeichnisadministratorkonto mit dem Benutzernamen Admin und dem angegebenen Passwort. Mit diesem Konto verwalten Sie das Verzeichnis.
+ Erstellt eine Sicherheitsgruppe für die Verzeichniscontroller.

Wenn Sie eine starten AWS Directory Service for Microsoft Active Directory, AWS erstellt eine Organisationseinheit (OU), die alle Objekte Ihres Verzeichnisses enthält. Diese OU erhält den NetBIOS-Namen, den Sie beim Erstellen des Verzeichnisses eingegeben haben, und befindet sich im Domainstamm. Der Domänenstamm gehört und wird von verwaltet AWS. 

 Das *Admin*-Konto, das zusammen mit dem Verzeichnis AWS Managed Microsoft AD erstellt wurde, verfügt über die Berechtigungen für die häufigsten administrativen Aufgaben in Bezug auf Ihre OU: 
+ Erstellen, Aktualisieren oder Löschen von Benutzern, Gruppen und Computern 
+ Hinzufügen von Ressourcen zu Ihrer Domäne, etwa Datei- oder Druckserver, und anschließendes Gewähren der zugehörigen Ressourcenberechtigungen für Benutzer und Gruppen in der OU. 
+ Erstellen Sie zusätzliche OUs Container.
+ Delegieren von Befugnissen. 
+ Erstellen und Verknüpfen von Gruppenrichtlinien. 
+ Wiederherstellen von gelöschten Objekten aus dem Active Directory-Papierkorb. 
+ Führen Sie AD- und PowerShell DNS-Windows-Module im Active Directory-Webdienst aus. 

Das Admin-Konto verfügt zudem über die Rechte zum Ausführen der folgenden domänenübergreifenden Aktivitäten: 
+ Verwalten von DNS-Konfigurationen (Hinzufügen, Entfernen oder Aktualisieren von Datensätzen, Zonen und Weiterleitungen). 
+ Aufrufen von DNS-Ereignisprotokollen. 
+ Anzeigen von Sicherheitsereignisprotokollen. 

**Um ein Verzeichnis zu erstellen mit AWS Managed Microsoft AD**

1. Wählen Sie im Navigationsbereich der [Directory Service -Konsole](https://console.aws.amazon.com/directoryservicev2/) die Option **Directories (Verzeichnisse)** und dann **Set up directory (Verzeichnis einrichten)** aus.

1. Wählen Sie **AWS Managed Microsoft AD**. Dies ist zurzeit die einzige für Amazon RDS unterstützte Option.

1. Wählen Sie **Weiter** aus.

1. Geben Sie auf der Seite **Enter directory information (Verzeichnisinformationen eingeben)** die folgenden Informationen ein:   
**Edition**  
 Wählen Sie die Edition aus, die Ihre Anforderungen erfüllt.  
**DNS-Name des Verzeichnisses**  
Den vollständig qualifizierten Namen für das Verzeichnis, z. B. `corp.example.com`. Namen, die länger als 47 Zeichen sind, werden von SQL Server nicht unterstützt.  
**NetBIOS-Name des Verzeichnisses**  
Ein optionaler Kurzname für das Verzeichnis, z. B. `CORP`.   
**Verzeichnisbeschreibung**  
Eine optionale Beschreibung des Verzeichnisses.   
**Administratorpasswort**  
Das Passwort für den Verzeichnisadministrator. Während des Verzeichniserstellungsprozesses wird ein Administratorkonto mit dem Benutzernamen Admin und diesem Passwort angelegt.   
Das Passwort für den Verzeichnisadministrator darf nicht das Wort „“ enthalte `admin`. Beachten Sie beim Passwort die Groß- und Kleinschreibung und es muss 8 bis 64 Zeichen lang sein. Zudem muss es mindestens ein Zeichen aus dreien der vier folgenden Kategorien enthalten:   
   + Kleinbuchstaben (a – z)
   + Großbuchstaben (A – Z)
   + Zahlen (0 – 9)
   + Nicht-alphanumerische Zeichen (\$1\$1@\$1\$1%^&\$1\$1-\$1=`\$1\$1()\$1\$1[]:;"'<>,.?/)   
**Passwort bestätigen**  
Geben Sie das Administratorpasswort erneut ein. 

1. Wählen Sie **Weiter** aus.

1. Geben Sie auf der Seite **Choose VPC and subnets (VPC und Subnetze wählen)** die folgenden Informationen an.  
**VPC**  
Wählen Sie die VPC für das Verzeichnis aus.  
Sie können das Verzeichnis und die DB-Instance an unterschiedlichen Orten lokalisieren. Wenn Sie dies tun VPCs, stellen Sie jedoch sicher, dass Sie den VPC-übergreifenden Verkehr aktivieren. Weitere Informationen finden Sie unter [Schritt 4: Aktivieren des VPC-übergreifenden Datenverkehrs zwischen dem Verzeichnis und der DB-Instance](#USER_SQLServerWinAuth.SettingUp.VPC-Peering).  
**Subnetze**  
Wählen Sie Subnetze für die Verzeichnis-Server aus. Die beiden Subnetze müssen zu verschiedenen Availability-Zonen gehören.

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie die Verzeichnisinformationen. Falls Sie noch Änderungen vornehmen möchten, klicken Sie auf **Previous (Zurück)**. Wenn die Informationen richtig sind, wählen Sie **Create directory (Verzeichnis erstellen)**.   
![\[Seite Überprüfen und Erstellen\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth2.png)

Es dauert einige Minuten, bis das Verzeichnis erstellt wurde. Wenn es erfolgreich erstellt wurde, ändert sich der Wert **Status** in **Active (Aktiv)**.

Um Informationen über das Verzeichnis anzuzeigen, wählen Sie die Verzeichnis-ID in der Verzeichnisauflistung aus. Notieren Sie sich den Wert **Directory ID (Verzeichnis-ID)**. Sie benötigen diesen Wert, wenn Sie die SQL Server-DB-Instance erstellen oder modifizieren.

![\[Seite „Directory details (Verzeichnisdetails)“\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth3.png)


## Schritt 2: Erstellen der IAM-Rolle für die Verwendung durch Amazon RDS
<a name="USER_SQLServerWinAuth.SettingUp.CreateIAMRole"></a>

Wenn Sie die Konsole zum Erstellen der SQL Server-DB-Instance verwenden, können Sie diesen Schritt überspringen. Wenn Sie zum Erstellen der SQL Server-DB-Instance die CLI oder RDS-API verwenden, müssen Sie eine IAM-Rolle erstellen, die die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` verwendet. Diese Rolle ermöglicht es Amazon RDS, Directory Service für Sie Anrufe an die zu tätigen. 

Wenn Sie statt der AWS verwalteten `AmazonRDSDirectoryServiceAccess` Richtlinie eine benutzerdefinierte Richtlinie für den Beitritt zu einer Domain verwenden, stellen Sie sicher, dass Sie die `ds:GetAuthorizedApplicationDetails` Aktion zulassen. Diese Anforderung gilt aufgrund einer Änderung der Directory Service API ab Juli 2019.

Die folgende IAM-Richtlinie (`AmazonRDSDirectoryServiceAccess`) ermöglicht den Zugriff auf Directory Service.

**Example IAM-Richtlinie für die Bereitstellung des Zugriffs auf Directory Service**    
****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
            "ds:DescribeDirectories", 
            "ds:AuthorizeApplication", 
            "ds:UnauthorizeApplication",
            "ds:GetAuthorizedApplicationDetails"
        ],
      "Effect": "Allow",
      "Resource": "*"
    }
  ]
}
```

Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.

Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Anweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.

Stellen Sie in der Vertrauensbeziehung sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen Amazon-Ressourcennamen (ARN) der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie für die Windows-Authentifizierung sicher, dass Sie die DB-Instances einschließen, wie im folgenden Beispiel gezeigt.

**Example Vertrauensbeziehung mit dem globalen Bedingungskontextschlüssel für die Windows-Authentifizierung**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "rds.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "aws:SourceArn": [
                        "arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
                    ]
                }
            }
        }
    ]
}
```

Erstellen Sie eine IAM-Rolle mit dieser IAM-Richtlinie und Vertrauensbeziehung. Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Erstellen von kundenverwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#create-managed-policy-console) im *IAM-Benutzerhandbuch*.

## Schritt 3: Erstellen und Konfigurieren von Benutzern und Gruppen
<a name="USER_SQLServerWinAuth.SettingUp.CreateUsers"></a>

Sie können Benutzer und Gruppen mit dem Tool "Active Directory-Benutzer und -Computer" erstellen. Dieses Tool ist eines der "Active Directory Domain Services"- und "Active Directory Lightweight Directory Services"-Tools. „Benutzer“ sind Einzelpersonen oder Entitäten, die Zugriff auf Ihr Verzeichnis haben. Gruppen sind sehr nützlich, um Berechtigungen zu erteilen oder zu verweigern, anstatt diese Berechtigungen für jeden einzelnen Benutzer erstellen zu müssen.

Um Benutzer und Gruppen in einem Directory Service Verzeichnis zu erstellen, müssen Sie mit einer Windows EC2-Instance verbunden sein, die Mitglied des Directory Service Verzeichnisses ist. Außerdem müssen Sie als Benutzer angemeldet sein, der über Rechte zum Erstellen von Benutzern und Gruppen verfügt. Weitere Informationen finden [Sie unter Hinzufügen von Benutzern und Gruppen (Simple AD und AWS Managed Microsoft AD)](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/creating_ad_users_and_groups.html) im *AWS Directory Service Administratorhandbuch*.

## Schritt 4: Aktivieren des VPC-übergreifenden Datenverkehrs zwischen dem Verzeichnis und der DB-Instance
<a name="USER_SQLServerWinAuth.SettingUp.VPC-Peering"></a>

Wenn Sie beabsichtigen, das Verzeichnis und die DB-Instance in derselben VPC zu platzieren, überspringen Sie diesen Schritt und fahren Sie mit for [Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance](#USER_SQLServerWinAuth.SettingUp.CreateModify).

[Wenn Sie planen, das Verzeichnis und die DB-Instance unterschiedlich zu lokalisieren VPCs, konfigurieren Sie den VPC-übergreifenden Verkehr mithilfe von VPC-Peering oder Transit Gateway.AWS](https://docs.aws.amazon.com/vpc/latest/tgw/what-is-transit-gateway.html)

Das folgende Verfahren ermöglicht den Datenverkehr zwischen VPCs mithilfe von VPC-Peering. Folgen Sie den Anleitungen unter [Was ist VPC Peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) im *Handbuch zu Amazon Virtual Private Cloud-Peering*.

**Aktivieren des VPC-übergreifenden Datenverkehrs mit VPC Peering**

1. Richten Sie geeignete VPC-Routing-Regeln ein, um sicherzustellen, dass Netzwerk-Datenverkehr in beide Richtungen fließen kann.

1. Stellen Sie sicher, dass die Sicherheitsgruppe der DB-Instance eingehenden Datenverkehr von der Sicherheitsgruppe des Verzeichnisses empfangen kann.

1. Stellen Sie sicher, dass keine ACL-Regel (Network Access Control List) zum Blockieren des Datenverkehrs vorhanden ist.

Wenn ein anderes AWS Konto Eigentümer des Verzeichnisses ist, müssen Sie das Verzeichnis gemeinsam nutzen.

**Um das Verzeichnis von mehreren AWS Konten gemeinsam zu nutzen**

1. *Beginnen Sie mit der gemeinsamen Nutzung des Verzeichnisses mit dem AWS Konto, unter dem die DB-Instance erstellt werden soll. Folgen Sie dazu den Anweisungen im [Administratorhandbuch unter Tutorial: Teilen Ihres AWS Managed Microsoft AD Verzeichnisses für einen nahtlosen EC2-Domänenbeitritt](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html).Directory Service *

1. Melden Sie sich mit dem Konto für die DB-Instance bei der Directory Service Konsole an und stellen Sie sicher, dass die Domain den `SHARED` Status hat, bevor Sie fortfahren.

1. Notieren Sie sich den Wert der **Verzeichnis-ID**, während Sie mit dem Konto für die DB-Instance bei der Directory Service Konsole angemeldet sind. Sie verwenden diese Verzeichnis-ID, um die DB-Instance mit der Domäne zu verbinden.

## Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance
<a name="USER_SQLServerWinAuth.SettingUp.CreateModify"></a>

Erstellen oder ändern Sie eine SQL Server-DB-Instance für die Verwendung mit Ihrem Verzeichnis. Sie können die Konsole, CLI oder RDS-API verwenden, um eine DB-Instance einem Verzeichnis zuzuordnen. Sie können dafür eine der folgenden Möglichkeiten auswählen:
+ Erstellen Sie mit der Konsole, dem [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)CLI-Befehl oder dem Vorgang [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API eine neue SQL Server-DB-Instance.

  Detaillierte Anweisungen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ändern Sie eine vorhandene SQL Server-DB-Instance mithilfe der Konsole, des [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI-Befehls oder der Operation [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API.

  Detaillierte Anweisungen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Stellen Sie mithilfe der Konsole, des CLI-Befehls -db-snapshot oder des API-Vorgangs Restore From DBSnapshot RDS eine SQL [restore-db-instance-fromServer-DB-Instance DBInstance aus einem DB-Snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) [wieder her](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html).

  Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance point-in-time mithilfe der Konsole, des Befehls [restore-db-instance-to- point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) CLI oder der Operation [Restore DBInstance ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API in einer wieder her.

  Detaillierte Anweisungen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).

 Die Windows-Authentifizierung wird nur für SQL Server-DB-Instances in einer VPC unterstützt. 

 Damit die DB-Instance das von Ihnen erstellte Domänenverzeichnis verwenden kann, ist Folgendes erforderlich: 
+  Für **Directory (Verzeichnis)** müssen Sie den Domänenbezeichner (`d-ID`) auswählen, der beim Erstellen des Verzeichnisses generiert wurde.
+  Stellen Sie sicher, dass die VPC-Sicherheitsgruppe über eine ausgehende Regel verfügt, mit der die DB-Instance mit dem Verzeichnis kommunizieren kann.

![\[Microsoft SQL Server-Windows-Authentifizierungsverzeichnis\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth1.png)


Wenn Sie den verwenden AWS CLI, sind die folgenden Parameter erforderlich, damit die DB-Instance das von Ihnen erstellte Verzeichnis verwenden kann:
+ Für den `--domain`-Parameter verwenden Sie den Domänenbezeichner (`d-ID`), der beim Erstellen des Verzeichnisses generiert wurde.
+ Verwenden Sie für den `--domain-iam-role-name`-Parameter die von Ihnen erstellte Rolle, die die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` verwendet.

Beispielsweise ändert der folgende CLI-Befehl eine DB-Instance zur Verwendung eines Verzeichnisses.

Für Linux, macOS oder Unix:

```
aws rds modify-db-instance \
    --db-instance-identifier mydbinstance \
    --domain d-ID \
    --domain-iam-role-name role-name
```

Für Windows:

```
aws rds modify-db-instance ^
    --db-instance-identifier mydbinstance ^
    --domain d-ID ^
    --domain-iam-role-name role-name
```

**Wichtig**  
Wenn Sie eine DB-Instance zur Aktivierung der Kerberos-Authentifizierung ändern, starten Sie die DB-Instance neu, nachdem Sie die Änderung vorgenommen haben.

## Schritt 6: Erstellen von SQL Server-Anmeldungen für die Windows-Authentifizierung
<a name="USER_SQLServerWinAuth.CreateLogins"></a>

Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Hauptbenutzer, um eine Verbindung zur SQL Server-DB-Instance herzustellen, wie Sie es bei jeder anderen DB-Instance tun würden. Da die DB-Instance mit der AWS Managed Microsoft AD Domäne verbunden ist, können Sie SQL Server-Logins und -Benutzer bereitstellen. Sie tun dies über die Active Directory-Benutzer und -Gruppen in Ihrer Domäne. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.

Damit ein Active Directory-Benutzer sich mit SQL Server authentifizieren kann, muss eine SQL Server-Windows-Anmeldung für den Benutzer oder für eine Gruppe, der der Benutzer angehört, vorliegen. Eine differenzierte Zugriffskontrolle wird durch das Gewähren und Widerrufen von Berechtigungen für diese SQL Server-Anmeldungen gewährleistet. Ein Benutzer, der keine SQL Server-Anmeldung hat oder zu keiner Gruppe mit einer solchen Anmeldung gehört, kann nicht auf die SQL Server-DB-Instance zugreifen.

Die Berechtigung ALTER ANY LOGIN ist erforderlich, um eine SQL Server-Anmeldung für das Active-Directory zu erstellen. Wenn Sie mit dieser Berechtigung noch keine Anmeldungen erstellt haben, verbinden Sie sich mithilfe der SQL Server-Authentifizierung als Masterbenutzer der DB-Instance.

Führen Sie den folgenden Data Definition Language (DDL)-Befehl aus, um eine SQL Server-Anmeldung für einen Active-Directory-Benutzer oder eine entsprechende Gruppe zu erstellen.

**Anmerkung**  
Geben Sie Benutzer und Gruppen unter Verwendung des Anmeldenamens von Windows 2000 im Format a `domainName\login_name`. Sie können keinen User Principle Name (UPN) im Format verwenden *`login_name`*`@`*`DomainName`*.  
Sie können eine Windows-Authentifizierungsanmeldung nur auf einer Instance von RDS für SQL Server mithilfe von T-SQL-Anweisungen erstellen. Sie können SQL Server Management Studio nicht verwenden, um eine Windows-Authentifizierungsanmeldung zu erstellen.

```
USE [master]
GO
CREATE LOGIN [mydomain\myuser] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO
```

Weitere Informationen finden Sie unter [ANMELDENAME ERSTELLEN (Transact-SQL)](https://msdn.microsoft.com/en-us/library/ms189751.aspx) in der Microsoft Developer Network-Dokumentation.

Benutzer (sowohl menschliche Benutzer als auch Anwendungen) von Ihrer Domäne können sich nun von einem über eine Domäne verbundenen Client-Computer mithilfe der Windows-Authentifizierung an der RDS-for-SQL-Server-Instance anmelden.

# Verwalten einer DB-Instance in einer Domäne
<a name="USER_SQLServerWinAuth.Managing"></a>

 Sie können die Konsole oder die Amazon RDS-API verwenden AWS CLI, um Ihre DB-Instance und ihre Beziehung zu Ihrer Domain zu verwalten. Beispielsweise können Sie die DB-Instance in Domänen, aus Domänen oder zwischen Domänen verschieben. 

 Sie können z. B. mithilfe der Amazon-RDS-API Folgendes tun: 
+  Um erneut zu versuchen, einer Domain für eine fehlgeschlagene Mitgliedschaft beizutreten, verwenden Sie den Vorgang DBInstance API [modifizieren](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) und geben Sie die Verzeichnis-ID der aktuellen Mitgliedschaft an. 
+  Um den IAM-Rollennamen für die Mitgliedschaft zu aktualisieren, verwenden Sie die `ModifyDBInstance`-API-Operation und geben Sie die Verzeichnis-ID der aktuellen Mitgliedschaft und die neue IAM-Rolle an. 
+  Um eine DB-Instance aus einer Domäne zu entfernen, verwenden Sie die `ModifyDBInstance`-API-Operation und geben Sie `none` als Domänenparameter an. 
+  Um eine DB-Instance von einer Domäne in eine andere zu verschieben, verwenden Sie die `ModifyDBInstance` API-Operation. Geben Sie die Domänen-ID der neuen Domäne als Domänenparameter an. 
+  Verwenden Sie den DBInstances API-Vorgang [Describe](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html), um die Mitgliedschaft für jede DB-Instance aufzulisten. 

## Grundlegendes zur Domänenmitgliedschaft
<a name="USER_SQLServerWinAuth.Understanding"></a>

 Nachdem Sie Ihre DB-Instance erstellt oder modifiziert haben, wird die Instance ein Mitglied der Domäne. Die AWS Konsole zeigt den Status der Domain-Mitgliedschaft für die DB-Instance an. Der Status der DB-Instance kann einer der folgenden sein: 
+  **joined** – Die Instance ist Mitglied der Domäne.
+  **joining** – Die Instance ist gerade im Prozess, Mitglied einer Domäne zu werden.
+  **pending-join** – Die Mitgliedschaft der Instance steht noch aus.
+  **pending-maintenance-join**— versucht, AWS die Instance während des nächsten geplanten Wartungsfensters zu einem Mitglied der Domain zu machen.
+  **pending-removal** – Das Entfernen der Instance von der Domäne steht noch aus.
+  **pending-maintenance-removal**— versucht, AWS die Instanz während des nächsten geplanten Wartungsfensters aus der Domain zu entfernen.
+  **failed** – Ein Konfigurationsproblem hat verhindert, dass die Instance mit der Domäne verbunden werden konnte. Überprüfen und korrigieren Sie Ihre Konfiguration, bevor Sie den Befehl zu Änderung der Instance erneut ausführen.
+  **removing** – Die Instance wird gerade von der Domäne entfernt.

Eine Anfrage, Mitglied einer Domäne zu werden, kann wegen eines Netzwerkverbindungsproblems oder einer falschen IAM-Rolle fehlschlagen. Beispielsweise können Sie eine DB-Instance erstellen oder eine vorhandene Instance ändern und der Versuch, dass die DB-Instance Mitglied einer Domäne wird, wird fehlschlagen. Geben Sie in diesem Fall entweder den Befehl, um die DB-Instance zu erstellen oder zu ändern, neu aus oder ändern Sie die neu erstellte Instance, um der Domäne beizutreten.

# Herstellen einer Verbindung zu SQL Server mithilfe der Windows-Authentifizierung
<a name="USER_SQLServerWinAuth.Connecting"></a>

Um sich mithilfe der Windows-Authentifizierung mit dem SQL Server zu verbinden, müssen Sie als Domänenbenutzer an einem Computer angemeldet sein, der mit einer Domäne verbunden ist. Nach dem Starten des SQL Server Management Studios wählen Sie **Windows-Authentifizierung** als Authentifizierungsart, wie im Folgenden dargestellt.

![\[Verbindung zum SQL Server mithilfe der Windows-Authentifizierung\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth4.png)


## Wiederherstellen einer SQL Server DB-Instance und Hinzufügen zu einer Domäne
<a name="USER_SQLServerWinAuth.Restore"></a>

Sie können einen DB-Snapshot wiederherstellen oder eine point-in-time Wiederherstellung (PITR) für eine SQL Server-DB-Instance durchführen und sie dann einer Domäne hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, modifizieren Sie die Instance, indem Sie den unter [Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance](USER_SQLServerWinAuth.SettingUp.md#USER_SQLServerWinAuth.SettingUp.CreateModify) beschriebenen Prozess anwenden, um die DB-Instance einer Domäne hinzuzufügen.