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.

Erste Schritte mit AD Connector

Mit AD Connector können Sie eine Verbindung AWS Directory Service zu Ihrem bestehenden Unternehmen herstellen Active Directory. Wenn Sie mit Ihrem vorhandenen Verzeichnis verbunden sind, verbleiben all Ihre Verzeichnisdaten auf Ihren Domänencontrollern. AWS Directory Service repliziert keine Ihrer Verzeichnisdaten.

AD-Connector-Voraussetzungen

Zum Herstellen einer Verbindung mit Ihrem vorhandenen Verzeichnis über AD Connector benötigen Sie Folgendes:

AWS IAM Identity Center Voraussetzungen

Wenn Sie IAM Identity Center mit AD Connector verwenden möchten, müssen Sie sicherstellen, dass Folgendes zutrifft:

Weitere Informationen finden Sie unter Voraussetzungen für IAM Identity Center im AWS IAM Identity Center Benutzerhandbuch.

Voraussetzungen für Multifaktor-Authentifizierung

Für die Unterstützung von Multi-Faktor-Authentifizierung in Ihrem AD-Connector-Verzeichnis benötigen Sie Folgendes:

Weitere Informationen zur Verwendung von AD Connector mit MFA finden Sie unterMulti-Faktor-Authentifizierung für AD Connector aktivieren.

Zuweisen von Berechtigungen zu Ihrem Servicekonto

Für die Verbindung mit Ihrem vorhandenen Verzeichnis benötigen Sie die Anmeldeinformationen für ein AD-Connector-Servicekonto im vorhandenen Verzeichnis, dem bestimmte Berechtigungen zugewiesen wurden. Obwohl Mitglieder der Gruppe Domain-Administratoren über ausreichende Berechtigungen verfügen, um das Verzeichnis aufzurufen, ist es eine bewährte Methode, ein Servicekonto zu verwenden, das nur über die Berechtigungen verfügt, die zum Aufrufen des Verzeichnisses mindestens notwendig sind. Das folgende Verfahren zeigt, wie Sie eine neue Gruppe mit dem Namen erstellenConnectors, die erforderlichen Rechte delegieren, die für die Verbindung mit AWS Directory Service dieser Gruppe erforderlich sind, und dann ein neues Dienstkonto zu dieser Gruppe hinzufügen.

Dieses Verfahren muss auf einem Computer ausgeführt werden, der mit Ihrem Verzeichnis verknüpft ist und auf dem das MMC Snap-In „Active Directory-Benutzer und -Computer“ installiert ist. Außerdem müssen Sie als Domain-Administrator angemeldet sein.

Testen Sie Ihren AD Connector

Damit AD Connector eine Verbindung zu Ihrem vorhandenen Verzeichnis herstellen kann, muss die Firewall für Ihr vorhandenes Netzwerk bestimmte Ports CIDRs für beide Subnetze in der VPC geöffnet haben. Um zu prüfen, ob das der Fall ist, führen Sie die folgenden Schritte aus:

Nachfolgend der Quellcode für die Anwendung DirectoryServicePortTest.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.DirectoryServices.ActiveDirectory;
using System.Threading;
using System.DirectoryServices.AccountManagement;
using System.DirectoryServices;
using System.Security.Authentication;
using System.Security.AccessControl;
using System.Security.Principal;

namespace DirectoryServicePortTest
{
    class Program
    {
        private static List<int> _tcpPorts;
        private static List<int> _udpPorts;

        private static string _domain = "";
        private static IPAddress _ipAddr = null;

        static void Main(string[] args)
        {
            if (ParseArgs(args))
            {
                try
                {
                    if (_domain.Length > 0)
                    {
                        try
                        {
                            TestForestFunctionalLevel();

                            TestDomainFunctionalLevel();
                        }
                        catch (ActiveDirectoryObjectNotFoundException)
                        {
                            Console.WriteLine("The domain {0} could not be found.\n", _domain);
                        }
                    }

                    if (null != _ipAddr)
                    {
                        if (_tcpPorts.Count > 0)
                        {
                            TestTcpPorts(_tcpPorts);
                        }

                        if (_udpPorts.Count > 0)
                        {
                            TestUdpPorts(_udpPorts);
                        }
                    }
                }
                catch (AuthenticationException ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            else
            {
                PrintUsage();
            }

            Console.Write("Press <enter> to continue.");
            Console.ReadLine();
        }

        static void PrintUsage()
        {
            string currentApp = Path.GetFileName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            Console.WriteLine("Usage: {0} \n-d <domain> \n-ip \"<server IP address>\" \n[-tcp \"<tcp_port1>,<tcp_port2>,etc\"] \n[-udp \"<udp_port1>,<udp_port2>,etc\"]", currentApp);
        }

        static bool ParseArgs(string[] args)
        {
            bool fReturn = false;
            string ipAddress = "";

            try
            {
                _tcpPorts = new List<int>();
                _udpPorts = new List<int>();

                for (int i = 0; i < args.Length; i++)
                {
                    string arg = args[i];

                    if ("-tcp" == arg | "/tcp" == arg)
                    {
                        i++;
                        string portList = args[i];
                        _tcpPorts = ParsePortList(portList);
                    }

                    if ("-udp" == arg | "/udp" == arg)
                    {
                        i++;
                        string portList = args[i];
                        _udpPorts = ParsePortList(portList);
                    }

                    if ("-d" == arg | "/d" == arg)
                    {
                        i++;
                        _domain = args[i];
                    }

                    if ("-ip" == arg | "/ip" == arg)
                    {
                        i++;
                        ipAddress = args[i];
                    }
                }
            }
            catch (ArgumentOutOfRangeException)
            {
                return false;
            }

            if (_domain.Length > 0 || ipAddress.Length > 0)
            {
                fReturn = true;
            }

            if (ipAddress.Length > 0)
            { 
                _ipAddr = IPAddress.Parse(ipAddress); 
            }
            
            return fReturn;
        }

        static List<int> ParsePortList(string portList)
        {
            List<int> ports = new List<int>();

            char[] separators = {',', ';', ':'};

            string[] portStrings = portList.Split(separators);
            foreach (string portString in portStrings)
            {
                try
                {
                    ports.Add(Convert.ToInt32(portString));
                }
                catch (FormatException)
                {
                }
            }

            return ports;
        }

        static void TestForestFunctionalLevel()
        {
            Console.WriteLine("Testing forest functional level.");

            DirectoryContext dirContext = new DirectoryContext(DirectoryContextType.Forest, _domain, null, null);
            Forest forestContext = Forest.GetForest(dirContext);

            Console.Write("Forest Functional Level = {0} : ", forestContext.ForestMode);

            if (forestContext.ForestMode >= ForestMode.Windows2003Forest)
            {
                Console.WriteLine("PASSED");
            }
            else
            {
                Console.WriteLine("FAILED");
            }

            Console.WriteLine();
        }

        static void TestDomainFunctionalLevel()
        {
            Console.WriteLine("Testing domain functional level.");

            DirectoryContext dirContext = new DirectoryContext(DirectoryContextType.Domain, _domain, null, null);
            Domain domainObject = Domain.GetDomain(dirContext);

            Console.Write("Domain Functional Level = {0} : ", domainObject.DomainMode);

            if (domainObject.DomainMode >= DomainMode.Windows2003Domain)
            {
                Console.WriteLine("PASSED");
            }
            else
            {
                Console.WriteLine("FAILED");
            }

            Console.WriteLine();
        }

        static List<int> TestTcpPorts(List<int> portList)
        {
            Console.WriteLine("Testing TCP ports to {0}:", _ipAddr.ToString());

            List<int> failedPorts = new List<int>();

            foreach (int port in portList)
            {
                Console.Write("Checking TCP port {0}: ", port);

                TcpClient tcpClient = new TcpClient();

                try
                {
                    tcpClient.Connect(_ipAddr, port);

                    tcpClient.Close();
                    Console.WriteLine("PASSED");
                }
                catch (SocketException)
                {
                    failedPorts.Add(port);
                    Console.WriteLine("FAILED");
                }
            }

            Console.WriteLine();

            return failedPorts;
        }

        static List<int> TestUdpPorts(List<int> portList)
        {
            Console.WriteLine("Testing UDP ports to {0}:", _ipAddr.ToString());

            List<int> failedPorts = new List<int>();

            foreach (int port in portList)
            {
                Console.Write("Checking UDP port {0}: ", port);

                UdpClient udpClient = new UdpClient();

                try
                {
                    udpClient.Connect(_ipAddr, port);
                    udpClient.Close();
                    Console.WriteLine("PASSED");
                }
                catch (SocketException)
                {
                    failedPorts.Add(port);
                    Console.WriteLine("FAILED");
                }
            }

            Console.WriteLine();

            return failedPorts;
        }
    }
}

Einen AD Connector erstellen

Führen Sie die folgenden Schritte aus, um mit AD Connector eine Verbindung zu einem vorhandenen Verzeichnis herzustellen. Bevor Sie dieses Verfahren beginnen, stellen Sie sicher, dass Sie die in AD-Connector-Voraussetzungen angegebenen Voraussetzungen erfüllt haben.

Weitere Informationen darüber, was mit Ihrem AD Connector erstellt wird, finden Sie unterWas wird mit Ihrem AD Connector erstellt.