

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 Microsoft Active Directory mit RDS Custom für SQL Server
<a name="custom-sqlserver-WinAuth"></a>

RDS Custom für SQL Server ermöglicht es, Ihre Instances zu einem selbstverwalteten Active Directory (AD) oder AWS Managed Microsoft AD zu verbinden. Dies gilt unabhängig davon, wo Ihr AD gehostet wird, z. B. in einem On-Premises-Rechenzentrum, Amazon EC2 oder bei einem anderen Cloud-Serviceanbieter.

Zur Authentifizierung von Benutzern und Services können Sie die NTLM- oder Kerberos-Authentifizierung in Ihren DB-Instances von RDS für SQL Server nutzen, ohne zwischengeschaltete Domains und Gesamtstruktur-Vertrauensstellungen verwenden zu müssen. Wenn ein Benutzer versucht, sich auf Ihrer DB-Instance von RDS Custom für SQL Server mit einem selbst hinzugefügten Active Directory zu authentifizieren, werden Authentifizierungsanfragen an ein von Ihnen angegebenes selbstverwaltetes AD oder AWS Managed Microsoft AD weitergeleitet.

In den folgenden Abschnitten finden Sie Informationen zum Arbeiten mit einem selbstverwalteten Active Directory und mit einem von AWS verwalteten Active Directory für RDS Custom für SQL Server.

**Topics**
+ [Verfügbarkeit von Regionen und Versionen](#custom-sqlserver-WinAuth.Regions)
+ [Konfigurieren eines selbstverwalteten oder On-Premises-AD](custom-sqlserver-WinAuth.config-Self-Managed.md)
+ [Konfigurieren Sie Microsoft Active Directory mit Directory Service](custom-sqlserver-WinAuth.config-ADS.md)
+ [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md)
+ [Validieren des Netzwerks](custom-sqlserver-WinAuth.NWValidation.md)
+ [Einrichten einer Windows-Authentifizierung für Instances von RDS Custom für SQL Server](custom-sqlserver-WinAuth.settingUp.md)
+ [Verwalten einer DB-Instance in einer Domäne](custom-sqlserver-WinAuth.ManagingDBI.md)
+ [Grundlegendes zur Domänenmitgliedschaft](custom-sqlserver-WinAuth.Understanding.md)
+ [Problembehebung bei Active Directory](custom-sqlserver-WinAuth.Troubleshoot.md)

## Verfügbarkeit von Regionen und Versionen
<a name="custom-sqlserver-WinAuth.Regions"></a>

RDS Custom für SQL Server unterstützt in allen Regionen, in denen RDS Custom für SQL Server unterstützt wird, sowohl selbstverwaltete AD als auch AWS Managed Microsoft AD mit NTLM oder Kerberos. Weitere Informationen finden Sie unter [Unterstützte Regionen und DB-Engines für RDS Custom](Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.md).

# Konfigurieren eines selbstverwalteten oder On-Premises-AD
<a name="custom-sqlserver-WinAuth.config-Self-Managed"></a>

Um Ihr On-Premises- oder selbstverwaltetes Microsoft AD mit Ihrer DB-Instance von RDS Custom für SQL Server zu verknüpfen, muss Ihre Active Domain wie folgt konfiguriert sein:
+ Definieren Sie die Subnetze in der VPC, die Ihrer DB-Instance von RDS Custom für SQL Server zugeordnet ist, in Ihrem selbstverwalteten oder On-Premises-AD. Vergewissern Sie sich, dass keine Konflikte zwischen den Subnetzen in Ihrer VPC und den Subnetzen an Ihren AD-Standorten vorhanden sind. 
+ Ihr AD-Domain-Controller weist die Domain-Funktionsebene Windows Server 2008 R2 oder höher auf.
+ Ihr AD-Domain-Name darf nicht im Single Label Domain (SLD)-Format vorliegen. RDS Custom 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="custom-sqlserver-WinAuth.config-Self-Managed.network"></a>

Konfigurieren Sie die Netzwerkkonnektivität Ihres selbstverwalteten oder On-Premises-AD wie folgt:
+ Richten Sie die Konnektivität zwischen der Amazon VPC, auf der Ihre Instance von RDS Custom für SQL Server ausgeführt wird, und Ihrem AD ein. Verwenden Sie Direct Connect, Site-to-Site VPN AWS Transit Gateway, und VPC Peering.
+ Lassen Sie Datenverkehr über die Ports Ihrer RDS Custom for SQL Server-Sicherheitsgruppen und Ihres Netzwerks ACLs zu Ihrem selbstverwalteten oder lokalen AD zu. Weitere Informationen finden Sie unter [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md).  
![\[Microsoft SQL Server-Windows-Authentifizierungsverzeichnis\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/custom-sqs-SM-NC.png)

## Konfigurieren der DNS-Auflösung
<a name="custom-sqlserver-WinAuth.config-Self-Managed.DNS"></a>

Richten Sie die folgenden Anforderungen ein, um die DNS-Auflösung mit selbstverwalteten oder On-Premises-ADs zu konfigurieren:
+ Konfigurieren Sie die DNS-Auflösung in Ihrer VPC, um den vollständig qualifizierten Domain-Namen (FQDN) Ihres selbstgehosteten Active Directorys aufzulösen. Ein Beispiel für einen FQDN ist `corp.example.local`. Um die DNS-Auflösung zu konfigurieren, konfigurieren Sie den VPC-DNS-Resolver so, dass Anfragen für bestimmte Domains mit einem ausgehenden Endpunkt von Amazon Route 53 und einer Resolver-Regel weitergeleitet werden. Weitere Informationen finden Sie unter [Configure a Route 53 Resolver outbound endpoint to resolve DNS records](https://repost.aws/knowledge-center/route53-resolve-with-outbound-endpoint).
+ Für Workloads, die VPCs sowohl Ressourcen als auch lokale Ressourcen nutzen, müssen Sie lokal gehostete DNS-Einträge auflösen. Lokale Ressourcen müssen möglicherweise Namen auflösen, die auf gehostet werden. AWS

  Um eine Hybrid-Cloud-Einrichtung zu erstellen, verwenden Sie Resolver-Endpunkte und Regeln für die bedingte Weiterleitung, um DNS-Abfragen zwischen Ihren On-Premises-Ressourcen und Ihrer benutzerdefinierten VPC aufzulösen. Weitere Informationen finden Sie unter [Auflösen von DNS-Abfragen zwischen VPCs und Ihrem Netzwerk](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-overview-DSN-queries-to-vpc.html) im *Amazon Route 53-Entwicklerhandbuch*.

**Wichtig**  
Das Ändern der DNS-Resolver-Einstellungen der Netzwerkschnittstelle auf RDS Custom für SQL Server führt dazu, dass DNS-fähige VPC-Endpunkte nicht mehr ordnungsgemäß funktionieren. DNS-fähige VPC-Endpunkte sind für Instances in privaten Subnetzen ohne Internetzugang erforderlich.

# Konfigurieren Sie Microsoft Active Directory mit Directory Service
<a name="custom-sqlserver-WinAuth.config-ADS"></a>

AWS Managed Microsoft AD erstellt ein vollständig verwaltetes Microsoft Active Directory AWS , das auf Windows Server 2019 basiert und auf den Funktionsebenen 2012 R2 Forest und Domain betrieben wird. Directory Service erstellt die Domain-Controller in verschiedenen Subnetzen in einer Amazon VPC, sodass Ihr Verzeichnis auch bei einem Ausfall hochverfügbar ist.

Informationen zum Erstellen eines Verzeichnisses mit AWS Managed Microsoft AD finden Sie unter [Erste Schritte mit AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) im *AWS Directory Service Administratorhandbuch*.

## Konfigurieren Ihrer Netzwerkkonnektivität
<a name="custom-sqlserver-WinAuth.config-ADS.network"></a>

### Aktivieren des VPC-übergreifenden Datenverkehrs zwischen dem Verzeichnis und der DB-Instance
<a name="custom-sqlserver-WinAuth.config-ADS.network.x-vpc"></a>

Um das Verzeichnis und die DB-Instance in derselben VPC zu platzieren, überspringen Sie diesen Schritt und fahren Sie mit dem nächsten Schritt unter [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md) fort.

Um das Verzeichnis und die DB-Instance unterschiedlich zu lokalisieren VPCs, konfigurieren Sie den VPC-übergreifenden Verkehr mithilfe von VPC-Peering oder. AWS Transit Gateway Weitere Informationen zur Verwendung von VPC-Peering finden Sie unter [Was ist VPC-Peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html)? im *Amazon VPC Peering Guide* und [Was ist? AWS Transit Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/what-is-transit-gateway.html) in den *Amazon VPC Transit Gateways*.

**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. Gestatten Sie der Sicherheitsgruppe der DB-Instance, eingehenden Datenverkehr von der Sicherheitsgruppe des Verzeichnisses zu empfangen. Weitere Informationen finden Sie unter [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md).

1. Die Netzwerk-Zugriffssteuerungsliste (ACL) darf den Datenverkehr nicht blockieren.

Wenn das Verzeichnis einer anderen AWS-Konto Person gehört, müssen Sie das Verzeichnis gemeinsam nutzen. *Um das Verzeichnis, AWS-Konto in dem sich die RDS Custom for SQL Server-Instanz befindet, gemeinsam zu nutzen, folgen Sie dem [Tutorial: Sharing your AWS Managed Microsoft AD for seamless EC2 domain-join](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html) im AWS Directory Service Administrationshandbuch.*

**Gemeinsames Verwenden eines Verzeichnisses zwischen AWS-Konten**

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

1. Nachdem Sie sich mit dem Konto für die DB-Instance bei der Directory Service Konsole angemeldet haben, notieren Sie sich den Wert für die **Verzeichnis-ID**. Sie verwenden diese ID, um die DB-Instance mit der Domain zu verbinden.

## Konfigurieren der DNS-Auflösung
<a name="custom-sqlserver-WinAuth.config-ADS.DNS"></a>

Wenn Sie ein Verzeichnis mit erstellen AWS Managed Microsoft AD, Directory Service erstellt zwei Domänencontroller und fügt den DNS-Dienst in Ihrem Namen hinzu.

Wenn Sie über eine bestehende VPC als Ihre RDS Custom for SQL Server-DB-Instance verfügen AWS Managed Microsoft AD oder planen, eine solche in einer anderen VPC zu starten, konfigurieren Sie den VPC-DNS-Resolver so, dass er Abfragen für bestimmte Domänen mit einer Route 53 53-Regel für ausgehende Verbindungen und Resolver weiterleitet. Weitere Informationen finden [Sie unter Konfiguration eines ausgehenden Route 53-Resolver-Endpunkts](https://repost.aws/knowledge-center/route53-resolve-with-outbound-endpoint) zur Auflösung von DNS-Einträgen.

# Portregeln für die Netzwerkkonfiguration
<a name="custom-sqlserver-WinAuth.NWConfigPorts"></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 Custom für SQL Server erstellen möchten, und Ihrem selbstverwalteten Active Directory oder AWS Managed Microsoft AD wurde konfiguriert. Richten Sie für ein selbstverwaltetes Active Directory die Konnektivität mithilfe von AWS Direct Connect, AWS VPN, VPC-Peering oder AWS Transit Gateway ein. Richten Sie für AWS Managed Microsoft AD die Konnektivität mithilfe von VPC-Peering ein.
+ Stellen Sie sicher, dass die Sicherheitsgruppe und die VPC-Netzwerk-ACLs für das/die Subnetz(e), in dem/denen Sie Ihre DB-Instance von RDS Custom für SQL Server erstellen, Datenverkehr an den Ports und in den Richtungen zulassen, die in der folgenden Abbildung dargestellt sind.  
![\[Microsoft Active Directory – Netzwerkkonfiguration – Portregeln\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/custom_sqlserver_ActiveDirectory_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/custom-sqlserver-WinAuth.NWConfigPorts.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 VPC-Netzwerk-ACLs verwenden, müssen Sie auch ausgehenden Datenverkehr über dynamische Ports (49152–65535) von Ihrer DB-Instance von RDS Custom für SQL Server zulassen. Stellen Sie sicher, dass sich diese Datenverkehrsregeln auch auf den Firewalls widerspiegeln, die für die einzelnen AD-Domain-Controller, DNS-Server und DB-Instances von RDS Custom für SQL Server gelten.  
Während VPC-Sicherheitsgruppen eine Öffnung der Ports nur in der Richtung verlangen, in der der Netzwerkverkehr initiiert wird, erfordern die meisten Windows-Firewalls und VPC-Netzwerk-ACLs eine Öffnung der Ports in beide Richtungen.

# Validieren des Netzwerks
<a name="custom-sqlserver-WinAuth.NWValidation"></a>

Bevor Sie Ihre RDS-Custom-Instance entweder zu selbstverwaltetem oder AWS Managed Microsoft AD hinzufügen, überprüfen Sie Folgendes von einer EC2-Instance in derselben VPC, in der Sie die Instance von RDS Custom für SQL Server starten möchten. 
+ Prüfen Sie, ob Sie den vollständig qualifizierten Domain-Namen (FQDN) in Domain-Controller-IPs auflösen können.

  ```
  nslookup corp.example.com
  ```

  Der Befehl muss eine Ausgabe ähnlich der folgenden zurückgeben:

  ```
  Server:  ip-10-0-0-2.us-west-2.compute.internal
  Address:  25.0.0.2
  
  Non-authoritative answer:
  Name:    corp.example.com
  Addresses:  40.0.9.25 (DC1 IP)
              40.0.50.123 (DC2 IP)
  ```
+ Lösen Sie AWS-Services von einer EC2-Instance in der VPC auf, in der Sie Ihre RDS-Custom-Instance starten:

  ```
  $region='input-your-aws-region'
  $domainFQDN='input-your-domainFQDN'
   
  function Test-DomainPorts {
      param (
          [string]$Domain,
          [array]$Ports
      )
   
      foreach ($portInfo in $Ports) {
          try {
              $conn = New-Object System.Net.Sockets.TcpClient
              $connectionResult = $conn.BeginConnect($Domain, $portInfo.Port, $null, $null)
              $success = $connectionResult.AsyncWaitHandle.WaitOne(1000) # 1 second timeout
              if ($success) {
                  $conn.EndConnect($connectionResult)
                  $result = $true
              } else {
                  $result = $false
              }
          }
          catch {
              $result = $false
          }
          finally {
              if ($null -ne $conn) {
                  $conn.Close()
              }
          }
          Write-Host "$($portInfo.Description) port open: $result"
      }
  }
   
  # Check if ports can be reached 
  $ports = @(
      @{Port = 53;   Description = "DNS"},
      @{Port = 88;   Description = "Kerberos"},
      @{Port = 389;  Description = "LDAP"},
      @{Port = 445;  Description = "SMB"},
      @{Port = 5985; Description = "WinRM"},
      @{Port = 636;  Description = "LDAPS"},
      @{Port = 3268; Description = "Global Catalog"},
      @{Port = 3269; Description = "Global Catalog over SSL"},
      @{Port = 9389; Description = "AD DS"}
  )
   
  function Test-DomainReachability {
      param (
          [string]$DomainName
      )
      
      try {
          $dnsResults = Resolve-DnsName -Name $DomainName -ErrorAction Stop
          Write-Host "Domain $DomainName is successfully resolving to following IP addresses: $($dnsResults.IpAddress)"
          Write-Host ""
          return $true
      } 
      catch {
          Write-Host ""
          Write-Host "Error Message: $($_.Exception.Message)"
          Write-Host "Domain $DomainName reachability check failed, please Configure DNS resolution"
          return $false
      }
  }
   
  $domain = (Get-WmiObject Win32_ComputerSystem).Domain
  if ($domain -eq 'WORKGROUP') {
      Write-Host ""    
      Write-Host "Host $env:computername is still part of WORKGROUP and not part of any domain"
      }
  else {
      Write-Host ""
      Write-Host "Host $env:computername is joined to $domain domain"
      Write-Host ""
      }
   
   
  $isReachable = Test-DomainReachability -DomainName $domainFQDN  
  if ($isReachable) {
      write-Host "Checking if domain $domainFQDN is reachable on required ports  "
      Test-DomainPorts -Domain $domainFQDN -Ports $ports
  }
  else {
      Write-Host "Port check skipped. Domain not reachable"
  }   
   
   
   
  # Get network adapter configuration
  $networkConfig = Get-WmiObject Win32_NetworkAdapterConfiguration | 
                   Where-Object { $_.IPEnabled -eq $true } |
                   Select-Object -First 1
   
  # Check DNS server settings
  $dnsServers = $networkConfig.DNSServerSearchOrder
   
  if ($dnsServers) {
      Write-Host "`nDNS Server settings:"
      foreach ($server in $dnsServers) {
          Write-Host "  - $server"
      }
  } else {
      Write-Host "`nNo DNS servers configured or unable to retrieve DNS server information."
  }
   
  write-host ""
   
  # Checks reachability to dependent services
  $services = "s3", "ec2", "secretsmanager", "logs", "events", "monitoring", "ssm", "ec2messages", "ssmmessages"
   
  function Get-TcpConnectionAsync {
      param (
          $ServicePrefix,
          $region
      )
      $endpoint = "${ServicePrefix}.${region}.amazonaws.com"
      $tcp = New-Object Net.Sockets.TcpClient
      $result = $false
   
      try {
          $connectTask = $tcp.ConnectAsync($endpoint, 443)
          $timedOut = $connectTask.Wait(3000)
          $result = $tcp.Connected
      } 
      catch {
          $result = $false
      } 
      return $result
  }
   
  foreach ($service in $services) {
      $validationResult = Get-TcpConnectionAsync -ServicePrefix $service -Region $region
      Write-Host "Reachability to $service is $validationResult"
  }
  ```

  Der Wert für `TcpTestSucceeded` muss `True` für `s3`, `ec2`, `secretsmanager`, `logs`, `events`, `monitoring`, `ssm`, `ec2messages` und `ssmmessages` zurückgeben.

# Einrichten einer Windows-Authentifizierung für Instances von RDS Custom für SQL Server
<a name="custom-sqlserver-WinAuth.settingUp"></a>

Wir empfehlen, für jedes AWS-Konto, das eine DB-Instance von RDS Custom für SQL Server besitzt, die Ihrer AD-Domain hinzugefügt wurde, eine dedizierte Organisationseinheit und dieser Organisationseinheit zugeordnete Service-Anmeldeinformationen zu erstellen. Durch die Zuordnung einer Organisationseinheit und der Service-Anmeldeinformationen können Sie widersprüchliche Berechtigungen vermeiden und dem Prinzip der geringsten Berechtigung folgen.

Gruppenrichtlinien auf Active-Directory-Ebene können zu Konflikten mit AWS-Automatisierungen und -Berechtigungen führen. Es wird empfohlen, GPOs auszuwählen, die nur für die Organisationseinheit gelten, die Sie für RDS Custom für SQL Server erstellen.
+ Um Organisationseinheit- und AD-Domain-Benutzer in Ihrem selbstverwalteten oder On-Premises-AD zu erstellen, können Sie den Domain-Controller als Domain-Administrator verbinden.
+ Zum Erstellen von Benutzern und Gruppen in einem Directory Service-Verzeichnis müssen Sie mit einer Management-Instance verbunden und als Benutzer angemeldet sein, der dazu berechtigt ist, Benutzer und Gruppen zu erstellen. Weitere Informationen finden Sie unter [User and group management in AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html) im *AWS Directory Service-Administrationshandbuch*.
+ Um Ihr Active Directory über eine Windows-Server-Instance von Amazon EC2 zu verwalten, müssen Sie Tools für Active Directory Domain Services und Active Directory Lightweight Directory Services auf der EC2-Instance installieren. Weitere Informationen finden Sie unter [Installing Active Directory Administration Tools for AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html) im *AWS Directory Service-Administrationshandbuch*.
+ Wir empfehlen, diese Tools zur Verwaltung auf einer separaten EC2-Instance und nicht auf Ihrer DB-Instance von RDS Custom für SQL Server zu installieren, um die Verwaltung zu vereinfachen.

Folgende Anforderungen gelten für ein AD-Domain-Servicekonto:
+ Sie müssen in Ihrer AD-Domain über ein Servicekonto mit delegierten Berechtigungen zum Hinzufügen von Computern zu der Domain verfügen. Ein Domain-Servicekonto ist ein Benutzerkonto in Ihrem AD, an das die Berechtigung zur Ausführung bestimmter Aufgaben delegiert wurde.
+ An das Domain-Servicekonto müssen in der Organisationseinheit, der Sie Ihre DB-Instance von RDS für SQL Server 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
+ Für selbstverwaltetes und On-Premises-AD muss das Domain-Servicekonto Mitglied der Gruppe „AWS Delegated Domain Name System Administrators“ sein.
+ Für AWS Managed Microsoft AD sollte das Domain-Servicekonto Mitglied der Gruppe „DnsAdmins“ sein.

Dies sind die erforderlichen Mindestberechtigungen, um Computerobjekte zu Ihrem selbstverwalteten Active Directory und AWS Managed Microsoft AD hinzuzufügen. Weitere Informationen finden Sie unter [Error: Access is denied when non-administrator users who have been delegated control try to join computers to a domain controller](https://learn.microsoft.com/en-us/troubleshoot/windows-server/active-directory/access-denied-when-joining-computers) in der Dokumentation zu Microsoft Windows Server.

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

**Topics**
+ [Schritt 1: Erstellen einer Organisationseinheit (OU) in Ihrem AD](#custom-sqlserver-WinAuth.settingUp.CreateOU)
+ [Schritt 2: Erstellen eines AD-Domain-Benutzers](#custom-sqlserver-WinAuth.settingUp.ADuser)
+ [Schritt 3: Delegieren der Kontrolle an den AD-Benutzer im selbstverwalteten oder AWS Managed Microsoft AD](#custom-sqlserver-WinAuth.settingUp.Delegate)
+ [Schritt 4: Erstellen eines Secrets](#custom-sqlserver-WinAuth.settingUp.ASM)
+ [Schritt 5: Erstellen oder Modifizieren einer DB-Instance von RDS Custom für SQL Server](#custom-sqlserver-WinAuth.settingUp.CreateDBInstance)
+ [Schritt 6: Erstellen einer SQL-Server-Anmeldung für die Windows-Authentifizierung](#custom-sqlserver-WinAuth.settingUp.CreateLogins)
+ [Schritt 7: Verwenden der Kerberos- oder NTLM-Authentifizierung](#custom-sqlserver-WinAuth.settingUp.KerbNTLM)

## Schritt 1: Erstellen einer Organisationseinheit (OU) in Ihrem AD
<a name="custom-sqlserver-WinAuth.settingUp.CreateOU"></a>

Führen Sie die folgenden Schritte aus, um eine Organisationseinheit in Ihrem AD zu erstellen:

**Erstellen einer Organisationseinheit in Ihrem AD**

1. Stellen Sie als Domain-Administrator eine Verbindung zu Ihrem Domain-AD 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.

   Aktivieren Sie **Container vor versehentlichem Löschen schützen**.

1. Wählen Sie **OK** aus. Ihre neue Organisationseinheit wird unter Ihrer Domain angezeigt.

Für AWS Managed Microsoft AD basiert der Name dieser Organisationseinheit auf dem NetBIOS-Namen, den Sie eingegeben haben, als Sie Ihr Verzeichnis erstellt haben. Eigentümer dieser Organisationseinheit ist AWS. Sie enthält alle Ihre mit AWS in Verbindung stehenden Verzeichnisobjekte, auf die Sie vollständigen Zugriff haben. Standardmäßig existieren zwei untergeordnete OUs unter dieser Organisationseinheit: **Computer und Benutzer**. Neue Organisationseinheiten, die RDS Custom erstellt, sind untergeordnete OUs der Organisationseinheit, die auf dem NetBIOS basiert.

## Schritt 2: Erstellen eines AD-Domain-Benutzers
<a name="custom-sqlserver-WinAuth.settingUp.ADuser"></a>

Die Anmeldeinformationen des Domain-Benutzers werden für das Secret in Secrets Manager verwendet.

**Erstellen eines AD-Domain-Benutzer in Ihrem AD**

1. Öffnen Sie **Active-Directory-Benutzer und -Computer** und wählen Sie die Domain und die Organisationseinheit aus, in der Sie den 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** oder **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 den AD-Benutzer im selbstverwalteten oder AWS Managed Microsoft AD
<a name="custom-sqlserver-WinAuth.settingUp.Delegate"></a>

**So delegieren Sie die Kontrolle an den AD-Domain-Benutzer in Ihrer Domain**

1. Öffnen Sie das MMC-Snap-In **Active-Directory-Benutzer und -Computer** und wählen Sie Ihre Domain aus.

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 unter **Benutzer, Computer oder Gruppen auswählen** den von Ihnen erstellten AD-Benutzer ein und klicken Sie auf **Namen überprüfen**. Wenn Ihre AD-Benutzerprüfung erfolgreich ist, klicken Sie auf **OK**.

1. Bestätigen Sie im Abschnitt **Benutzer oder Gruppen**, dass Ihr AD-Benutzer 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:

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

   Wählen Sie **Computerobjekte** aus.

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

   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:

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

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

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

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

## Schritt 4: Erstellen eines Secrets
<a name="custom-sqlserver-WinAuth.settingUp.ASM"></a>

Erstellen Sie das Secret in dem AWS-Konto und der Region, die die DB-Instance von RDS Custom für SQL Server enthalten, die Sie Ihrem Active Directory hinzufügen möchten. Speichern Sie die Anmeldeinformationen des AD-Domain-Benutzers, der in [Schritt 2: Erstellen eines AD-Domain-Benutzers](#custom-sqlserver-WinAuth.settingUp.ADuser) erstellt wurde.

------
#### [ Console ]
+ Wählen Sie unter AWS Secrets Manager die Option **Ein neues Secret speichern**.
+ Als **Secret-Typ** wählen Sie **Anderer Secret-Typ** aus.
+ Fügen Sie für **Schlüssel/Wert-Paare** zwei Schlüssel hinzu:
  + Geben Sie für den ersten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_USERNAME` und dann den Namen Ihres AD-Benutzers (ohne das Domain-Präfix) als Wert ein.
  + Geben Sie für den zweiten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_PASSWORD` und dann das Passwort für Ihren AD-Benutzer in Ihrer Domain ein.
+ Geben Sie als **Verschlüsselungsschlüssel** denselben AWS KMS-Schlüssel ein, mit dem Sie die Instance von RDS Custom für SQL Server erstellt haben.
+ Wählen Sie unter **Secret-Name** den Namen des Secrets aus, der mit `do-not-delete-rds-custom-` beginnt, damit Ihr Instance-Profil auf dieses Secret zugreifen kann. WENN Sie einen anderen Namen für das Secret wählen möchten, aktualisieren Sie `RDSCustomInstanceProfile` für den Zugriff auf **Secret-Name**.
+ (Optional) Geben Sie im Feld **Beschreibung** eine Beschreibung für den Secret-Namen ein.
+ Fügen Sie die Tags `Key="AWSRDSCustom",Value="custom-sqlserver"` hinzu. 
+ Klicken Sie auf **Speichern** und dann auf **Weiter**.
+ Behalten Sie für **Rotationseinstellungen konfigurieren** die Standardwerte bei und wählen Sie **Weiter** aus.
+ Überprüfen Sie die Einstellungen für das Secret und klicken Sie auf **Speichern**.
+ Wählen Sie das neue Secret aus und kopieren Sie den Wert für den **Secret-ARN**. Wir verwenden dies im nächsten Schritt, um Ihr Active Directory einzurichten.

------
#### [ CLI ]

Führen Sie in der CLI den folgenden Befehl aus, um Ihr Secret zu erstellen:

```
# Linux based
aws secretsmanager create-secret \
--name do-not-delete-rds-custom-DomainUserCredentails \ 
--description "Active directory user credentials for managing RDS Custom" \ 
--secret-string "{\"SELF_MANAGED_ACTIVE_DIRECTORY_USERNAME\":\"tester\",\"SELF_MANAGED_ACTIVE_DIRECTORY_PASSWORD\":\"xxxxxxxx\"}" \
--kms-key-id <RDSCustomKMSKey> \
--tags Key="AWSRDSCustom",Value="custom-sqlserver"

# Windows based
aws secretsmanager create-secret ^
--name do-not-delete-rds-custom-DomainUserCredentails ^ 
--description "Active directory user credentials for managing RDS Custom" ^
--secret-string "{\"SELF_MANAGED_ACTIVE_DIRECTORY_USERNAME\":\"tester\",\"SELF_MANAGED_ACTIVE_DIRECTORY_PASSWORD\":\"xxxxxxxx\"}" ^
--kms-key-id <RDSCustomKMSKey> ^
--tags Key="AWSRDSCustom",Value="custom-sqlserver"
```

------

## Schritt 5: Erstellen oder Modifizieren einer DB-Instance von RDS Custom für SQL Server
<a name="custom-sqlserver-WinAuth.settingUp.CreateDBInstance"></a>

Erstellen oder modifizieren Sie eine DB-Instance von SQL Server 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 eine neue SQL Server-DB-Instance mithilfe der Konsole, des CLI-Befehls [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) oder der [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)-RDS-API-Operation.

  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 CLI-Befehls [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) oder der [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)-RDS-API-Operation.

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

  Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance aus einem Snapshot mithilfe der Konsole, des CLI-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) oder der RDS-API-Operation [RestoreDBInstanceToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) wieder her.

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

**Anmerkung**  
Wenn Ihre Instance von RDS Custom für SQL Server bereits manuell mit einem AD verbunden ist, überprüfen Sie die Einstellungen für [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md) und [Validieren des Netzwerks](custom-sqlserver-WinAuth.NWValidation.md) und führen Sie die Schritte 1 bis 4 aus. Aktualisieren Sie `--domain-fqdn`, `--domain-ou` und `--domain-auth-secret-arn` für Ihr AD, sodass Anmeldeinformationen und Konfigurationen für die Domain-Verbindung bei RDS Custom registriert sind, um CNAME zu überwachen, zu registrieren und Wiederherstellungsmaßnahmen zu ergreifen. 

Wenn Sie die AWS CLI verwenden, sind die folgenden Parameter für die DB-Instance erforderlich, damit sie das erstellte Verzeichnis 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 erstellt haben.

**Wichtig**  
Wenn Sie eine DB-Instance ändern, um sie einer selbstverwalteten AD-Domain oder AWS Managed Microsoft AD 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 DB-Instance mit Single-AZ zu Ausfallzeiten. Ein DB-Cluster mit Multi-AZ führt ein Failover durch, bevor ein Neustart ausgeführt wird. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).

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

Für Linux, macOS oder Unix:

```
aws rds create-db-instance  \
--engine custom-sqlserver-se \
--engine-version 15.00.4312.2.v1 \
--db-instance-identifier my-custom-instance \
--db-instance-class db.m5.large \
--allocated-storage 100 --storage-type io1 --iops 1000 \
--master-username my-master-username \
--master-user-password my-master-password \
--kms-key-id  my-RDSCustom-key-id \
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance  \
--domain-fqdn "corp.example.com" \
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" \
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" \
--db-subnet-group-name my-DB-subnet-grp \
--vpc-security-group-ids  my-securitygroup-id \
--no-publicly-accessible \
--backup-retention-period 3 \
--port 8200 \
--region us-west-2 \
--no-multi-az
```

Für Windows:

```
aws rds create-db-instance  ^
--engine custom-sqlserver-se ^
--engine-version 15.00.4312.2.v1 ^
--db-instance-identifier my-custom-instance ^
--db-instance-class db.m5.large ^
--allocated-storage 100 --storage-type io1 --iops 1000 ^
--master-usernamemy-master-username ^
--master-user-password my-master-password ^
--kms-key-id  my-RDSCustom-key-id ^
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance  ^
--domain-fqdn "corp.example.com" ^
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" ^
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" ^
--db-subnet-group-name my-DB-subnet-grp ^
--vpc-security-group-ids  my-securitygroup-id ^
--no-publicly-accessible ^
--backup-retention-period 3 ^
--port 8200 ^
--region us-west-2 ^
--no-multi-az
```

**Wichtig**  
Wenn Ihr NetBIOS für AWS Managed Microsoft AD **corpexample** lautet, wird es selbst als Organisationseinheit angezeigt. Jede zuvor erstellte neue Organisationseinheit wird als verschachtelte Organisationseinheit angezeigt. Für AWS Managed Microsoft AD setzen Sie den Wert `--domain-ou` auf `"OU=RDSCustomOU,OU=corpexample,DC=corp,DC=example,DC=com"`.

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

Für Linux, macOS oder Unix:

```
aws rds modify-db-instance \
    --db-instance-identifier my-custom-instance \
    --domain-fqdn "corp.example.com" \
    --domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" \
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" \
```

Für Windows:

```
aws rds modify-db-instance ^
    --db-instance-identifier my-custom-instance ^
    --domain-fqdn "corp.example.com" ^
    --domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" ^
    --domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" ^
```

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

Für Linux, macOS oder Unix:

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

Für Windows:

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

Wenn Sie die Konsole verwenden, um Ihre Instance zu erstellen oder zu ändern, klicken Sie auf **Windows-Authentifizierung für Microsoft SQL Server aktivieren**, um die folgenden Optionen zu sehen.

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


Sie müssen sicherstellen, dass Ihr Domain-FQDN in die IP-Adressen des Domain-Controllers aufgelöst wird. Wenn Domain-Controller-IPs nicht aufgelöst werden, schlagen Domain-Verbindungsvorgänge fehl, aber die Erstellung der Instance von RDS Custom für SQL Server ist erfolgreich. Informationen zur Problembehebung finden Sie unter [Problembehebung bei Active Directory](custom-sqlserver-WinAuth.Troubleshoot.md). 

## Schritt 6: Erstellen einer SQL-Server-Anmeldung für die Windows-Authentifizierung
<a name="custom-sqlserver-WinAuth.settingUp.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 mit der AD-Domain verbunden ist, können Sie SQL-Server-Anmeldungen und -Benutzer bereitstellen. Sie tun dies über das AD-Dienstprogramm für Benutzer und Gruppen in Ihrer AD-Domain. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.

Damit ein AD-Benutzer sich mit SQL Server authentifizieren kann, muss eine Windows-Anmeldung für SQL Server für den AD-Benutzer oder für eine Active-Directory-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 AD-Benutzer, der keine SQL-Server-Anmeldung hat oder zu keiner AD-Gruppe mit einer solchen Anmeldung gehört, kann nicht auf die DB-Instance von SQL Server zugreifen.

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

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

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

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

## Schritt 7: Verwenden der Kerberos- oder NTLM-Authentifizierung
<a name="custom-sqlserver-WinAuth.settingUp.KerbNTLM"></a>

### NTLM-Authentifizierung mithilfe des RDS-Endpunkts
<a name="custom-sqlserver-WinAuth.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 herstellen.

Bei einer geplanten Datenbankwartung oder einer nicht geplanten Serviceunterbrechung erfolgt ein automatisches Failover von Amazon RDS zur aktuellen sekundären Datenbank, damit Vorgänge schnell und ohne manuelles Eingreifen fortgesetzt werden können. 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="custom-sqlserver-WinAuth.settingUp.KerbNTLM.Kerb"></a>

Für die Kerberos-basierte Authentifizierung für RDS Custom 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 Custom 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="custom-sqlserver-WinAuth.settingUp.KerbNTLM.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**.

Wenn Sie die EC2-Instance von RDS Custom verbinden und versuchen, mithilfe von CNAME eine lokale Verbindung zur Datenbank herzustellen, verwendet Ihre Verbindung die NTLM-Authentifizierung anstelle von Kerberos.

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;
```

# Verwalten einer DB-Instance in einer Domäne
<a name="custom-sqlserver-WinAuth.ManagingDBI"></a>

 Sie können die Konsole, AWS CLI oder die Amazon-RDS-API verwenden, um Ihre DB-Instance und ihre Beziehung zu Ihrer Domäne 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 eine Domänenverbindung herzustellen, die aufgrund einer fehlerhaften Mitgliedschaft fehlgeschlagen ist, verwenden Sie die API-Operation [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) und geben Sie die aktuelle Verzeichnis-ID der 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. 
+  Um die Mitgliedschaft für jede DB-Instance aufzulisten, führen Sie die API-Operation [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html) aus. 

## Wiederherstellen einer DB-Instance von RDS Custom für SQL Server und Hinzufügen zu einer Active-Directory-Domain
<a name="custom-sqlserver-WinAuth.ManagingDBI.Restoring"></a>

Sie können einen DB-Snapshot wiederherstellen oder eine zeitpunktbezogene Wiederherstellung (PITR) für eine DB-Instance von SQL Server vornehmen und diese dann zu einer Active-Directory-Domain hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, modifizieren Sie die Instance, indem Sie den unter [Schritt 5: Erstellen oder Modifizieren einer DB-Instance von RDS Custom für SQL Server](custom-sqlserver-WinAuth.settingUp.md#custom-sqlserver-WinAuth.settingUp.CreateDBInstance) beschriebenen Prozess anwenden, um die DB-Instance einer AD-Domain hinzuzufügen.

# Grundlegendes zur Domänenmitgliedschaft
<a name="custom-sqlserver-WinAuth.Understanding"></a>

 Nachdem Sie Ihre DB-Instance erstellt oder modifiziert haben, wird die Instance ein Mitglied der Domäne. Die AWS-Konsole gibt den Status der Domänenmitgliedschaft 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** – AWS versucht, die Instance im nächsten vorgesehenen Wartungsfenster zu einem Mitglieder der Domäne zu machen.
+  **pending-removal** – Das Entfernen der Instance von der Domäne steht noch aus.
+  **pending-maintenance-removal** – AWS versucht, die Instance im nächsten vorgesehenen Wartungsfenster von der Domäne 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.

# Problembehebung bei Active Directory
<a name="custom-sqlserver-WinAuth.Troubleshoot"></a>

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


| Fehlercode | Beschreibung | 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 Domain-Servicekonto verfügt nicht über die für den Beitritt zu der Organisationseinheit erforderlichen Berechtigungen. | Überprüfen Sie den Parameter `—domain-ou`. Stellen Sie sicher, dass das Domain-Servicekonto über die richtigen Berechtigungen für die Organisationseinheit verfügt. | 
| 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 DB-Instance von RDS Custom für SQL Server 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 Domain-Servicekonto 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. | 
| Fehler 234 / 0xEA | Die angegebene Organisationseinheit ist nicht vorhanden. | Die mit dem Parameter `—domain-ou` angegebene Organisationseinheit ist in Ihrem AD nicht vorhanden. | Überprüfen Sie den Parameter `—domain-ou` und stellen Sie sicher, dass die angegebene Organisationseinheit in Ihrem AD vorhanden ist. | 
| Fehler 1326 / 0x52E | Der Benutzername oder das Passwort ist falsch. | Die in AWS Secrets Manager angegebenen Anmeldeinformationen für das Domain-Servicekonto enthalten einen unbekannten Benutzernamen oder ein falsches Passwort. Möglicherweise ist das Domain-Konto auch in Ihrem AD deaktiviert. | Stellen Sie sicher, dass die in AWS Secrets Manager angegebenen Anmeldeinformationen korrekt sind und das Domain-Konto in Ihrem Active Directory aktiviert ist. | 
| Fehler 1355 / 0x54B | Die angegebene Domain ist nicht vorhanden oder konnte nicht kontaktiert werden. | Die Domain ist ausgefallen, der angegebene Satz von DNS-IPs 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 DB-Instance von RDS Custom für SQL Server und stellen Sie sicher, dass Ihr AD erreichbar ist. | 
| 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 DB-Instance von RDS Custom für SQL Server aus erreichbar sind. | 
| Fehler 2224 / 0x8B0 | Das Benutzerkonto besteht bereits. | Das Computerkonto, das zu Ihrem AD hinzugefügt werden soll, ist bereits vorhanden. | Ermitteln Sie das Computerkonto, indem Sie `SELECT @@SERVERNAME` auf Ihrer DB-Instance von RDS Custom für SQL Server ausführen, und entfernen Sie es dann vorsichtig aus Ihrem AD. | 
| Fehler 2242 / 0x8c2 | Das Passwort dieses Benutzers ist abgelaufen. | Das über AWS Secrets Manager angegebene Passwort für das Domain-Servicekonto ist abgelaufen. | Aktualisieren Sie das Passwort für das Domain-Servicekonto, über das Sie Ihre DB-Instance von RDS Custom für SQL Server Ihrem AD hinzufügen. | 