Prerequisiti di AD Connector Creazione di un AD Connector Cosa viene creato con il tuo AD Connector

Nozioni di base su AD Connector

Con AD Connector puoi connetterti AWS Directory Service alla tua azienda esistenteActive Directory. Quando si è connessi a una directory esistente, tutti i dati della directory rimangono sui controller dei domini. AWS Directory Service non replica alcun dato della directory.

Argomenti

Prerequisiti di AD Connector
Creazione di un AD Connector
Cosa viene creato con il tuo AD Connector

Prerequisiti di AD Connector

Per collegare la directory esistente a AD Connector, è necessario quanto segue:

Amazon VPC

Configura un VPC con quanto segue:

Almeno due sottoreti. Ciascuna sottorete deve trovarsi in una diversa zona di disponibilità.
VPCDeve essere connesso alla rete esistente tramite una connessione di rete privata virtuale (VPN) oppure AWS Direct Connect.
VPCDeve avere una tenancy hardware predefinita.

AWS Directory Service utilizza una struttura a due VPC strutture. Le EC2 istanze che compongono la directory vengono eseguite all'esterno dell' AWS account e sono gestite da AWS. Hanno due schede di rete, ETH0 e ETH1. ETH0 è la scheda di gestione ed è al di fuori del tuo account. ETH1 viene creata all'interno dell'account.

L'intervallo IP di gestione della ETH0 rete della directory viene scelto a livello di programmazione per garantire che non entri in conflitto con il VPC luogo in cui è distribuita la directory. Questo intervallo IP può trovarsi in una delle seguenti coppie (poiché le directory vengono eseguite in due sottoreti):

10.0.1.0/24 e 10.0.2.0/24
169.254,0/16
192.168.1.0/24 e 192.168.2.0/24

Evitiamo i conflitti controllando il primo ottetto di. ETH1 CIDR Se inizia con un 10, allora scegliamo un 192.168.0.0/16 con 192.168.1.0/24 e VPC 192.168.2.0/24 sottoreti. Se il primo ottetto è qualcosa di diverso da un 10, scegliamo un 10.0.0.0/16 con sottoreti 10.0.1.0/24 e 10.0.2.0/24. VPC

L'algoritmo VPC di selezione non include i percorsi sul tuo. È quindi possibile avere un conflitto di routing IP da questo scenario.

Per ulteriori informazioni, consulta i seguenti argomenti nella Amazon VPC User Guide:

Per ulteriori informazioni in merito AWS Direct Connect, consulta la Guida AWS Direct Connect per l'utente.

Esistente Active Directory

Dovrai connetterti a una rete esistente con un Active Directory dominio.

Nota

AD Connector non supporta i domini con etichetta singola.

Il livello di funzionalità di questo Active Directory dominio deve essere pari Windows Server 2003 o superiore. AD Connector supporta anche la connessione a un dominio ospitato su un'EC2istanza Amazon.

Nota

AD Connector non supporta i controller di dominio di sola lettura (RODC) se utilizzati in combinazione con la funzionalità Amazon EC2 domain-join.

Account del servizio

È necessario disporre delle credenziali di un account del servizio nella directory esistente a cui sono stati assegnati i seguenti privilegi:

Leggi utenti e gruppi - Obbligatorio
Unisci computer al dominio: richiesto solo quando si utilizza Seamless Domain Join e WorkSpaces
Creazione di oggetti informatici - Obbligatorio solo quando si utilizza Seamless Domain Join e WorkSpaces
La password dell'account del servizio deve essere conforme AWS ai requisiti in materia di password. AWS le password devono essere:
- Tra 8 e 128 caratteri di lunghezza, inclusi.
- Contengono almeno un carattere di tre delle quattro categorie seguenti:
  - Lettere minuscole (a-z)
  - Lettere maiuscole (A-Z)
  - Numeri (0-9)
  - Caratteri non alfanumerici (~!@#$%^&*_-+=`|\(){}[]:;"'<>,.?/)

Per ulteriori informazioni, consulta Delegare privilegi all'account del servizio.

Nota

AD Connector utilizza Kerberos per l'autenticazione e l'autorizzazione delle applicazioni AWS . LDAPviene utilizzato solo per la ricerca di oggetti di utenti e gruppi (operazioni di lettura). Con le LDAP transazioni, nulla è mutabile e le credenziali non vengono trasmesse in formato testo non crittografato. L'autenticazione è gestita da un servizio AWS interno, che utilizza i ticket Kerberos per eseguire operazioni LDAP come utente.

Autorizzazioni degli utenti

Tutti gli utenti di Active Directory devono avere le autorizzazioni necessarie per leggere i propri attributi, in particolare, quelli elencati di seguito:

GivenName
SurName
Mail
SamAccountName
UserPrincipalName
UserAccountControl
MemberOf

Per impostazione predefinita, gli utenti di Active Directory dispongono dell’autorizzazione in lettura per questi attributi. Queste autorizzazioni potrebbero essere modificate nel tempo dagli amministratori, quindi è opportuno verificare che gli utenti le abbiano prima di configurare AD Connector per la prima volta.

Indirizzi IP

Ottieni gli indirizzi IP di due DNS server o controller di dominio nella directory esistente.

AD Connector ottiene i _kerberos._tcp.<DnsDomainName> SRV record _ldap._tcp.<DnsDomainName> and da questi server quando si connette alla tua directory, quindi questi server devono contenere questi SRV record. AD Connector tenta di trovare un controller di dominio comune che fornisca entrambi LDAP i servizi Kerberos, quindi questi SRV record devono includere almeno un controller di dominio comune. Per ulteriori informazioni sui SRV record, vai a SRVResource Records on Microsoft TechNet.

Porte per sottoreti

Affinché AD Connector reindirizzi le richieste di directory ai controller di Active Directory dominio esistenti, il firewall della rete esistente deve avere le seguenti porte aperte CIDRs per entrambe le sottoreti di Amazon. VPC

TCP/53 - UDP DNS
TCP/UDP88 - Autenticazione Kerberos
TCP/389 UDP - LDAP

Queste sono le porte minime necessarie prima che AD Connector possa connettersi alla directory. La propria configurazione specifica potrebbe richiedere l'apertura di porte aggiuntive.

Se desideri utilizzare AD Connector e Amazon WorkSpaces, l'isableVLVSupportLDAPattributo D deve essere impostato su 0 per i controller di dominio. Questa è l'impostazione predefinita per i controller di dominio. AD Connector non sarà in grado di interrogare gli utenti nella directory se l'isableVLVSupportLDAPattributo D è abilitato. Ciò impedisce il funzionamento di AD Connector con Amazon WorkSpaces.

Nota

Se i DNS server o i server del controller di dominio del Active Directory dominio esistente si trovano all'interno diVPC, i gruppi di sicurezza associati a tali server devono avere le porte di cui sopra aperte a entrambe CIDRs le sottoreti di. VPC

Per ulteriori requisiti di porta, consulta Requisiti delle porte AD e AD DS nella Microsoft documentazione.

Preautenticazione Kerberos

I tuoi account utente devono avere la preautenticazione Kerberos abilitata. Per istruzioni dettagliate su come abilitare questa impostazione, vedi Assicurarsi che la preautenticazione di Kerberos sia abilitata. Per informazioni generali su questa impostazione, vai a Preautenticazione attiva Microsoft TechNet.

Tipi di crittografia

AD Connector supporta i seguenti tipi di crittografia durante l'autenticazione via Kerberos ai controller dei domini Active Directory:

AES-256- HMAC
AES-128- HMAC
RC4-HMAC

AWS IAM Identity Center prerequisiti

Se prevedi di utilizzare IAM Identity Center con AD Connector, devi assicurarti che quanto segue sia vero:

L'AD Connector è configurato nell'account di gestione della tua AWS organizzazione.
L'istanza di IAM Identity Center si trova nella stessa regione in cui è configurato AD Connector.

Per ulteriori informazioni, consulta i prerequisiti di IAM Identity Center nella Guida per l' AWS IAM Identity Center utente.

Prerequisiti dell'autenticazione a più fattori

Per supportare l'autenticazione a più fattori con la directory AD Connector, è necessario quanto segue:

Un server Remote Authentication Dial-In User Service (RADIUS) nella rete esistente con due endpoint client. Gli endpoint RADIUS client hanno i seguenti requisiti:
- Per creare gli endpoint, sono necessari gli indirizzi IP dei server AWS Directory Service . Questi indirizzi IP possono essere ottenuti dal campo Directory IP Address (Indirizzo IP della directory) dei dettagli della directory.
- Entrambi gli RADIUS endpoint devono utilizzare lo stesso codice segreto condiviso.
La rete esistente deve consentire il traffico in entrata attraverso la porta RADIUS server predefinita (1812) dai server. AWS Directory Service
I nomi utente tra il RADIUS server e la directory esistente devono essere identici.

Per ulteriori informazioni sull'utilizzo di AD Connector conMFA, consultaAbilitazione dell'autenticazione a più fattori per AD Connector.

Delegare privilegi all'account del servizio

Per connettersi alla directory esistente, è necessario disporre delle credenziali per l'account del servizio AD Connector nella directory esistente con determinati privilegi. Anche se i membri del gruppo Domain Admins (Amministratori del dominio) dispongono di privilegi sufficienti per connettersi alla directory, come best practice è consigliabile utilizzare un account del servizio che disponga solo dei privilegi minimi necessari per connettersi alla directory. La procedura seguente illustra come creare un nuovo gruppo chiamatoConnectors, delegare i privilegi necessari per connettersi AWS Directory Service a questo gruppo e quindi aggiungere un nuovo account di servizio a questo gruppo.

Questa procedura deve essere eseguita su un computer aggiunto alla directory in cui è installato lo snap-in Utenti e computer MMC di Active Directory. Inoltre, è necessario aver eseguito l'accesso come amministratore del dominio.

Delegare privilegi all'account del servizio

Apri Active Directory User and Computers (Utenti e computer di Active Directory) e seleziona la radice del dominio nell'albero di spostamento.
Nell'elenco nel riquadro a sinistra, fare clic con il pulsante destro del mouse su Utenti, selezionare Nuovo, quindi selezionare Gruppo.

Nella finestra di dialogo Nuovo oggetto Gruppo, inserire quanto segue e fare clic su OK.

Campo	Valore/Selezione
Group name (Nome gruppo)	`Connectors`
Ambito del gruppo	Globale
Tipo gruppo	Sicurezza

Nell'albero di navigazione Utenti e computer di Active Directory, selezionare Identifica l'unità organizzativa (OU) in cui verranno creati gli account dei computer. Nel menu, selezionare Azione e quindi Delega controllo. È possibile selezionare un'unità organizzativa principale fino al dominio in modo che le autorizzazioni si propaghino al figlio. OUs Se il tuo AD Connector è connesso a AWS Managed Microsoft AD, non avrai accesso al controllo delegato a livello di radice del dominio. In questo caso, per delegare il controllo, seleziona l'unità organizzativa nella directory OU in cui verranno creati gli oggetti computer.
Nella pagina Delega guidata del controllo, fare clic su Avanti, quindi fare clic su Aggiungi.
Nella finestra di dialogo Seleziona utenti, computer o gruppi, immettere Connectors e fare clic su OK. Se viene trovato più di un oggetto, selezionare il gruppo Connectors creato sopra. Fai clic su Next (Successivo).
Nella pagina Operazioni da delegare, selezionare Crea un'operazione personalizzata per eseguire la delega, quindi scegliere Avanti.
Selezionare Solo i seguenti oggetti contenuti nella cartella, quindi selezionare Oggetti computer e Oggetti utente.
Selezionare Crea gli oggetti selezionati in questa cartella e Elimina gli oggetti selezionati in questa cartella. Quindi scegli Successivo.
Seleziona Read (Lettura), quindi scegli Next (Avanti).

Nota
Se utilizzerai Seamless Domain Join oppure WorkSpaces, devi anche abilitare le autorizzazioni di scrittura in modo che Active Directory possa creare oggetti informatici.
Verificare le informazioni sulla pagina Completamento di Delega guidata del controllo e fare clic su Fine.
Creare un account utente con una password complessa e aggiungerlo al gruppo Connectors. Questo utente sarà noto come account del servizio AD Connector e, poiché ora è membro del Connectors gruppo, dispone ora di privilegi sufficienti per connettersi AWS Directory Service alla directory.

Test di un AD Connector

Affinché AD Connector si connetta alla directory esistente, il firewall della rete esistente deve avere determinate porte aperte CIDRs per entrambe le sottoreti di. VPC Per verificare se tali requisiti sono soddisfatti, eseguire i passaggi che seguono:

Per verificare la connessione

Avvia un'istanza di Windows in VPC e connettiti ad essa tramite. RDP L'istanza deve essere un membro del dominio esistente. I passaggi rimanenti vengono eseguiti su questa VPC istanza.
Scaricate e decomprimete l'applicazione DirectoryServicePortTestdi test. Il codice sorgente e i file di progetto Visual Studio sono inclusi, per cui è possibile modificare l'applicazione per i test, se necessario.

Nota
Questo script non è supportato su Windows Server 2003 o sistemi operativi precedenti.
Da un prompt dei comandi di Windows, eseguire l'applicazione per i test DirectoryServicePortTest con le seguenti opzioni:

Nota
L'applicazione di DirectoryServicePortTest test può essere utilizzata solo quando i livelli di funzionalità del dominio e della foresta sono impostati su Windows Server 2012 R2 e versioni precedenti.
```
DirectoryServicePortTest.exe -d <domain_name> -ip <server_IP_address> -tcp "53,88,389" -udp "53,88,389"
```
<domain_name>

Il nome di dominio completo. Questo viene utilizzato per testare la foresta e i livelli funzionali del dominio. Se si esclude il nome del dominio, non sarà effettuato alcun test sui livelli funzionali.

<server_IP_address>

L'indirizzo IP di un controller di dominio nel dominio esistente. Le porte saranno testate usando questo indirizzo IP. Se si esclude l'indirizzo IP, non sarà effettuato alcun test sulle porte.

Questa app di test determina se le porte necessarie dal dominio dell'VPCutente sono aperte e verifica inoltre i livelli minimi di funzionalità della foresta e del dominio.

L'output sarà simile al seguente:
```
Testing forest functional level.
Forest Functional Level = Windows2008R2Forest : PASSED

Testing domain functional level.
Domain Functional Level = Windows2008R2Domain : PASSED

Testing required TCP ports to <server_IP_address>:
Checking TCP port 53: PASSED
Checking TCP port 88: PASSED
Checking TCP port 389: PASSED

Testing required UDP ports to <server_IP_address>:
Checking UDP port 53: PASSED
Checking UDP port 88: PASSED
Checking UDP port 389: PASSED
```

Il seguente è il codice di origine per il modulo di risposta per l'applicazione 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;
        }
    }
}

Creazione di un AD Connector

Per collegarti alla tua directory esistente con AD Connector, procedi come segue. Prima di iniziare la procedura, assicurati di soddisfare i prerequisiti illustrati in Prerequisiti di AD Connector.

Nota

Non è possibile creare un AD Connector con un modello Cloud Formation.

Per connettersi con AD Connector

Nel riquadro di navigazione della Console AWS Directory Service, scegli Directory, quindi seleziona Configura directory.
Nella pagina Seleziona il tipo di directory, scegli AD Connector, quindi seleziona Successivo.
Nella pagina Enter AD Connector information (Inserisci le informazioni su AD Connector), fornire le seguenti informazioni:

Dimensione della directory

Scegliere tra l'opzione di dimensione Small (Piccola) o Large (Grande). Per ulteriori informazioni sulle dimensioni, consulta AD Connector.

Descrizione della directory

Descrizione opzionale della directory.
Nella pagina Scegli VPC e sottoreti, fornisci le seguenti informazioni, quindi scegli Avanti.

VPC

Il VPC per la directory.

Sottoreti

Scegli le sottoreti per i controller di dominio. Le due sottoreti devono trovarsi in diverse zone di disponibilità.
Nella pagina Connect to AD (Connettiti ad AD), fornire le seguenti informazioni:
DNSNome della directory

Il nome completo della directory esistente, ad esempio corp.example.com.

BIOSNome della directory Net

Il nome breve della directory esistente, ad esempio CORP.

DNSIndirizzi IP

L'indirizzo IP di almeno un DNS server nella directory esistente. Questi server devono essere accessibili da ciascuna sottorete specificata nella fase 4. Questi server possono essere posizionati all'esterno AWS, purché vi sia connettività di rete tra le sottoreti specificate e gli indirizzi IP del DNS server.

Nome utente dell'account del servizio

Il nome utente di un utente nella directory esistente. Per ulteriori informazioni su questo account, consultare Prerequisiti di AD Connector.

Password dell'account del servizio
La password per l'account dell'utente esistente. Questa password distingue tra maiuscole e minuscole e deve essere di lunghezza compresa tra 8 e 128 caratteri. Deve anche contenere un carattere di almeno tre delle seguenti quattro categorie:
Lettere minuscole (a-z)

Lettere maiuscole (A-Z)

Numeri (0-9)

Caratteri non alfanumerici (~!@#$%^&*_-+=`|\(){}[]:;"'<>,.?/)
Conferma la password

Immettere nuovamente la password per l'account dell'utente esistente.
Nella pagina Review & create (Rivedi e crea), esaminare le informazioni relative alla directory ed eseguire eventuali modifiche. Quando le informazioni sono corrette, scegli Create Directory (Crea directory). Per creare la directory sono necessari alcuni minuti. Una volta creato, il valore Status cambia in Active (Attivo).

Cosa viene creato con il tuo AD Connector

Quando crei un AD Connector, crea e associa AWS Directory Service automaticamente un'interfaccia di rete elastica (ENI) a ciascuna delle tue istanze di AD Connector. Ognuno di questi ENIs elementi è essenziale per la connettività tra te VPC e AWS Directory Service AD Connector e non deve mai essere eliminato. È possibile identificare tutte le interfacce di rete riservate all'uso AWS Directory Service mediante la descrizione: "interfaccia di rete AWS creata per directory directory-id». Per ulteriori informazioni, consulta Elastic Network Interfaces nella Amazon EC2 User Guide.

Nota

Le istanze AD Connector sono distribuite in due zone di disponibilità in una regione per impostazione predefinita e connesse al tuo Amazon Virtual Private Cloud ()VPC. Le istanze AD Connector che non funzionano vengono automaticamente sostituite nella stessa zona di disponibilità utilizzando lo stesso indirizzo IP.

Quando accedi a qualsiasi AWS applicazione o servizio integrato con un AD Connector (AWS IAM Identity Center incluso), l'app o il servizio inoltra la richiesta di autenticazione ad AD Connector, che a sua volta inoltra la richiesta a un controller di dominio nel tuo Active Directory autogestito per l'autenticazione. Se l'autenticazione è avvenuta correttamente nell'Active Directory autogestita, AD Connector restituisce quindi un token di autenticazione all'app o al servizio (simile a un token Kerberos). A questo punto, ora puoi accedere all'app o al AWS servizio.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

AD Connector

Procedura