Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Démarrer avec AD Connector

Avec AD Connector, vous pouvez vous connecter AWS Directory Service à votre entreprise existanteActive Directory. Lorsque vous êtes connecté à votre annuaire existant, toutes les données de celui-ci restent sur vos contrôleurs de domaine. AWS Directory Service ne réplique aucune des données de votre répertoire.

Conditions préalables requises pour AD Connector

Pour vous connecter à votre annuaire existant avec AD Connector, les éléments suivants sont requis :

AWS IAM Identity Center prérequis

Si vous envisagez d'utiliser l'IAM Identity Center avec AD Connector, vous devez vous assurer que ce qui suit est vrai :

Pour plus d'informations, consultez les conditions requises pour IAM Identity Center dans le guide de l' AWS IAM Identity Center utilisateur.

Prérequis pour l'authentification multifactorielle

Pour prendre en charge l'authentification multifactorielle avec votre annuaire AD Connector, les éléments suivants sont requis :

Pour en savoir plus sur l'utilisation d'AD Connector avec MFA, veuillez consulter Activer l'authentification multifactorielle pour AD Connector.

Délégation de privilèges à votre compte de service

Pour vous connecter à votre annuaire existant, vous devez disposer des informations d'identification pour votre compte de service AD Connector dans l'annuaire existant, auquel certains privilèges ont été délégués. Alors que les membres du groupe Administrateurs du domaine doivent avoir des privilèges suffisants pour se connecter à l'annuaire, en tant que bonne pratique, vous devez utiliser un compte de service disposant uniquement des privilèges minimum nécessaires pour la connexion à l'annuaire. La procédure suivante explique comment créer un nouveau groupe appeléConnectors, déléguer les privilèges nécessaires pour se connecter AWS Directory Service à ce groupe, puis ajouter un nouveau compte de service à ce groupe.

Cette procédure doit être effectuée sur un ordinateur qui est joint à votre annuaire et qui dispose du composant logiciel enfichable Utilisateurs et ordinateurs Active Directory. Vous devez également être connecté en tant qu'administrateur de domaine.

Test de votre connecteur AD Connector

Pour qu'AD Connector se connecte à votre annuaire existant, le pare-feu de votre réseau existant doit avoir certains ports ouverts vers les CIDR des deux sous-réseaux du VPC Pour vérifier si ces conditions sont satisfaites, exécutez les étapes suivantes :

Utilisez le code d'application suivant pour l'application 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;
        }
    }
}

Création d'un AD Connector

Pour vous connecter à votre annuaire existant avec AD Connector, procédez comme suit. Avant de commencer cette procédure, assurez-vous que vous avez terminé les prérequis identifiés dans Conditions préalables requises pour AD Connector.

Qu'est-ce qui est créé avec votre AD Connector

Lorsque vous créez un AD Connector, il crée et associe AWS Directory Service automatiquement une Elastic Network Interface (ENI) à chacune de vos instances AD Connector. Chacun de ces ENI est essentiel à la connectivité entre votre VPC et AD AWS Directory Service Connector et ne doit jamais être supprimé. Vous pouvez identifier toutes les interfaces réseau réservées à l'utilisation AWS Directory Service par la description : « interface réseau AWS créée pour le répertoire directory-id ». Pour plus d'informations, veuillez consulter la section Elastic Network Interfaces (français non garanti) dans le Guide de l'utilisateur Amazon EC2 pour les instances Windows.

Lorsque vous vous connectez à une AWS application ou à un service intégré à un AD Connector (AWS IAM Identity Center inclus), l'application ou le service transmet votre demande d'authentification à AD Connector, qui la transmet ensuite à un contrôleur de domaine dans votre Active Directory autogéré pour authentification. Si vous êtes authentifié avec succès auprès de votre Active Directory autogéré, AD Connector renvoie un jeton d'authentification à l'application ou au service (similaire à un jeton Kerberos). À ce stade, vous pouvez désormais accéder à l' AWS application ou au service.